Przydatne algorytmy/Moje opracowania/Algorytmy sortowania (tablice).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funkcje pomocnicze (testujące poprawność algorytmów)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Funkcja generująca losowe dane testowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "\n",
    "\n",
    "def non_uniform_randrange(range_, count, k=.2, ints_only=True, round_=2):\n",
    "    result = []\n",
    "    limit = k / (math.log(count) or 1 if count else 1)\n",
    "\n",
    "    while count:\n",
    "        range_size = range_[1] - range_[0]\n",
    "        while random.random() > limit and count:\n",
    "            if ints_only:\n",
    "                result.append(random.randint(*range_))\n",
    "            else:\n",
    "                random_num = round(random.random() * range_size + range_[0], round_)\n",
    "                result.append(random_num)\n",
    "            count -= 1\n",
    "\n",
    "        avg = sum(range_) / 2\n",
    "        delta = (avg - range_[0]) * k\n",
    "        range_ = (int(range_[0] + delta - .5), int(range_[1] - delta + .5))\n",
    "\n",
    "    return result\n",
    "\n",
    "\n",
    "def generate_test_data(val_counts=(0, 50),       # A minimum and maximum number of values to sort that will be generated\n",
    "                       range_=(-100, 100),       # A range which will be used to create a random list of values from this range\n",
    "                       ints_only=True,           # Set this flag to False in order to generate random non-integer numbers\n",
    "                       round_=2,                 # A number of floating point digits (works only with ints_only set to False\n",
    "                       uniform_distribution=True # If set to false, non-uniform values will be generated using a function above\n",
    "                       ):\n",
    "    if uniform_distribution:\n",
    "        if ints_only:\n",
    "            random_lst = [random.randint(*range_) for _ in range(random.randint(*val_counts))]\n",
    "        else:\n",
    "            random_lst = []\n",
    "            range_size = range_[1] - range_[0]\n",
    "            for _ in range(random.randint(*val_counts)):\n",
    "                # Shift a random value in order to be in range_ (not lower than the\n",
    "                # lower bound and not greater than the greater bound)\n",
    "                random_num = round(random.random() * range_size + range_[0], round_)\n",
    "                random_lst.append(random_num)\n",
    "    else:\n",
    "        random_lst = non_uniform_randrange(range_, random.randint(*val_counts), random.random() / 3, ints_only, round_)\n",
    "\n",
    "    return random_lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Funkcja testująca poprawność algorytmu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_sort(sorting_fn, *, \n",
    "              samples=20,                # A number of tests that will be performed\n",
    "              val_counts=(0, 50),        # A minimum and maximum number of values to sort that will be generated\n",
    "              range_=(-100, 100),        # A range which will be used to create a random list of values from this range\n",
    "              uniform_distribution=True, # If set to false, non-uniform values will be generated using a function above\n",
    "              modifies_arr=True,         # Information whether an algorithm modifies the initial array or returns a sorted array\n",
    "              failed_only=False,         # Show only failed tests. Works only if no_results is set to False\n",
    "              print_out_fn=None,         # An user-defined function to print additional information. Works only if no_results is set to False\n",
    "              no_results=False,          # When set to True, no results will be printed (useful only for benchmark)\n",
    "              ints_only=True,            # Set this flag to False in order to generate random non-integer numbers\n",
    "              round_=2                   # A number of floating point digits (works only with ints_only set to False)\n",
    "             ): \n",
    "    passed = 0                   \n",
    "    for i in range(samples):\n",
    "        random_lst = generate_test_data(val_counts, range_, ints_only, round_, uniform_distribution)\n",
    "        random_lst_before = random_lst[:] if modifies_arr else random_lst\n",
    "        \n",
    "        # Test if is correct\n",
    "        expected = sorted(random_lst)\n",
    "        if not modifies_arr:\n",
    "            result = sorting_fn(random_lst)\n",
    "        else:\n",
    "            sorting_fn(random_lst)\n",
    "            result = random_lst\n",
    "        is_correct = result == expected\n",
    "        passed += is_correct\n",
    "        \n",
    "        if not no_results:\n",
    "            if not failed_only or (failed_only and not is_correct):\n",
    "                print(f'TEST #{i+1}:')\n",
    "                print(f'Before sorting: {random_lst_before}')\n",
    "                print(f'After sorting: {result}')\n",
    "                print(f'Expected result: {expected}')\n",
    "                print(f'Test {\"PASSED\" if is_correct else \"FAILED\"}')\n",
    "                print(f'Current passed-to-tested ratio: {passed}/{i+1}')\n",
    "                if print_out_fn:\n",
    "                    print(f'========== Additional results after sorting  ==========')\n",
    "                    print_out_fn(random_lst)\n",
    "                print()\n",
    "                \n",
    "    if not no_results:\n",
    "        print(f'Sorting algorithm is {\"correct\" if passed == samples else \"wrong\"}')\n",
    "        print(f'Passed tests in total: {passed}/{samples}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Funkcja badająca wydajność algorytmów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from decimal import Decimal\n",
    "from colorama import Fore, Style\n",
    "\n",
    "# ATTENTION: This function doesn't check if an algorithm, works properly. In order to test\n",
    "# your algorithm's correctness, please use a function above\n",
    "def compare_performance(sorting_functions, *,      # sorting_functions[<fn name>] = (<fn variable>, <globals dict>)\n",
    "                        samples=100,               # A number of tests that will be performed\n",
    "                        val_counts=(0, 10_000),    # A minimum and maximum number of values to sort that will be generated\n",
    "                        range_=(-10_000, 10_000),  # A range which will be used to create a random list of values from this range\n",
    "                        progress_interval=10,      # A number of tests that will be performed between showing\n",
    "                                                   # current sorting times (temporary results). When set to 0 no progress will be displayed.\n",
    "                        uniform_distribution=True, # If set to false, non-uniform values will be generated using a function above\n",
    "                        ints_only=True             # Set this flag to False in order to generate random non-integer numbers\n",
    "                       ):                         \n",
    "    times = dict.fromkeys([fn[0] for fn in sorting_functions], Decimal(0))\n",
    "    max_fn_name_len = max(len(entry[0]) for entry in sorting_functions)\n",
    "    inf = float('inf')\n",
    "    \n",
    "    for i in range(1, samples + 1):\n",
    "        random_lst = generate_test_data(val_counts, range_, ints_only, 10, uniform_distribution)\n",
    "        \n",
    "        for name, (fn, globals_) in sorting_functions:\n",
    "            if times[name] == inf: continue\n",
    "            # Overwrite current global values to make an algorithm able to work (use a proper funciton)\n",
    "            for obj_name, obj in globals_.items():\n",
    "                globals()[obj_name] = obj\n",
    "            # Perform a test\n",
    "            input_lst = random_lst[:]\n",
    "            try:\n",
    "                start_time = time.time()\n",
    "                fn(input_lst)\n",
    "                end_time = time.time()\n",
    "            except RecursionError:\n",
    "                times[name] = inf\n",
    "            else:\n",
    "                times[name] += Decimal(end_time - start_time)\n",
    "            \n",
    "        if progress_interval > 0 and not i % progress_interval:\n",
    "            print(f\"===== Results after {i} tests: =====\")\n",
    "            names = sorted(times, key=lambda name: times[name])\n",
    "            fastest_time = times[names[0]]\n",
    "            for name in names:\n",
    "                total_time = times[name]\n",
    "                if total_time < inf:\n",
    "                    print(f\"{name.ljust(max_fn_name_len)}  Total (in seconds): {total_time:<8.4f}  Average: {total_time/i:<8.4f}\", end='')\n",
    "                    if fastest_time and name != names[0]:\n",
    "                        ratio = total_time / fastest_time\n",
    "                        print(f\"\\t({ratio:.2f}x slower)\")\n",
    "                    else:\n",
    "                        print()\n",
    "                else:\n",
    "                    print(f\"{name.ljust(max_fn_name_len)}   {Fore.RED}RECURSION ERROR{Style.RESET_ALL}\")\n",
    "            print()\n",
    "            \n",
    "    names = sorted(times, key=lambda name: times[name])\n",
    "    fastest_time = times[names[0]]\n",
    "    print(\"===== Final results: =====\")\n",
    "    print(f\"Tests performed: {samples}\")\n",
    "    print(\"\\nTotal times (in seconds):\")\n",
    "    for name in names:\n",
    "        total_time = times[name]\n",
    "        if total_time < inf:\n",
    "            print(f\"\\t{name.ljust(max_fn_name_len)}:   {total_time:.7f}\")\n",
    "        else:\n",
    "            print(f\"\\t{name.ljust(max_fn_name_len)}:   {Fore.RED}RECURSION ERROR{Style.RESET_ALL}\")\n",
    "    print(\"\\nAverage times (in seconds):\")\n",
    "    for name in names:\n",
    "        total_time = times[name]\n",
    "        if total_time < inf:\n",
    "            print(f\"\\t{name.ljust(max_fn_name_len)}:   {total_time/samples:<8.7f}\", end='')\n",
    "            if fastest_time and name != names[0]:\n",
    "                ratio = total_time / fastest_time\n",
    "                print(f\"\\t({ratio:.2f}x slower)\")\n",
    "            else:\n",
    "                print()\n",
    "        else:\n",
    "            print(f\"\\t{name.ljust(max_fn_name_len)}:   {Fore.RED}RECURSION ERROR{Style.RESET_ALL}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Słownik służący do zapisania funkcji, w celu porównania wydajności"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions = {}  # Please store sorting functions using function's name as a string\n",
    "                        # key and a (function variable, your specified global variables\n",
    "                        # such as helper functions that re used by a sorting function)\n",
    "                        # pairs as a value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorytmy o złożoności $ O(n^2) $\n",
    "### Zazwyczaj wolne, ale łatwe w implementacji i wytłumaczeniu algorytmy. Pozwalają na sortowanie dowolnych danych o dowolnym rozkładzie z dowolnego zakresu.\n",
    "##### Co ciekawe, algorytmy te są często szybsze od algorytmów szybkiego sortowania, jeżeli do posortowania mamy mały zbiór danych (kilkanaście elementów)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bubble Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n^2) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Stabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ponieważ wykonujemy zamiany sąsiednych wartości tylko wtedy, gdy jedna jest większa od drugiej. Kolejność żadnych dwóch elementów o tych samych kluczach, według których sortujemy daną sekwencję, nie zostanie zmieniona, ponieważ zamieniamy tylko te elementy, których klucze są różne, a klucz tego, który znajduje się wcześniej, jest większy od klucza tego, który znajduje się później (przy sortowaniu w kolejności malejącej, postępujemy odwrotnie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### * Powiemy, że sortowanie odbywa się w miejscu, jeżeli podczas procesu sortowania jest wykorzystywana stała ilość pamięci, niezależna od wielkości sortowanej struktury (tzn. elementy nie są tymczasowo przepisywane do struktur pomocniczych). Zazwyczaj** sortowanie w miejscu można odróżnić po tym, że po procesie sortowania zmodyfikowana zostaje sortowana struktura, a w przypadku sortowania, które nie sortuje w miejscu, zwrócona jest nowa struktura (tej samej wielkości, co wejściowa), zawierająca posortowane dane, a wejściowa struktura pozostaje nienaruszona."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ** Zazwyczaj, ponieważ możemy napisać funkcję, która \"przepisze\" posortowane dane z używanej tymczasowo struktury do sortowanej struktury, więc wejściowa struktura zostanie zmodyfikowana (patrz implementacja Merge Sort #2)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(arr):\n",
    "    for i in range(len(arr)-1):      \n",
    "        for j in range(len(arr)-1-i):\n",
    "            if arr[j] > arr[j+1]:\n",
    "                arr[j], arr[j+1] = arr[j+1], arr[j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bubble Sort'] = (bubble_sort, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(bubble_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selection Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n^2) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Niestabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wynika to stąd, że w każdym przebiegu wewnętrznej pętli, poszukujemy elementu, którgo klucz jest w danym momencie najmniejszy (największy - przy sortowaniu w kolejności nierosnącej) spośród kluczy elementów, znajdujących się w sprawdzanej w drugiej pętli elementów. Ponieważ sprawdzamy tylko te elementy sekwencji, które znajdują się dalej od elementu, na którym w danym momencie \"zatrzymała\" się zewnętrzna pętla oraz poszukujemy elementu najmniejszego spośród sprawdzanych, istnieje możliwość, że wskutek zamiany elementu najmniejszego z elementem z zewnętrznej pętli, element z zewnętrznej pętli znajdzie się dalej niż inny element, który posiada ten sam klucz. Wynika stąd, że wzajemna odległość elementów, które posiadają te same klucze, może zostać (i zazwyczaj jest) zmieniona."
   ]
  },
  {
   "attachments": {
    "SelectionSort.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Przykład:\n",
    "![SelectionSort.png](attachment:SelectionSort.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selection_sort(arr):\n",
    "    for i in range(len(arr)-1):\n",
    "        min_idx = i\n",
    "        for j in range(i+1, len(arr)):\n",
    "            if arr[j] < arr[min_idx]: min_idx = j\n",
    "        arr[i], arr[min_idx] = arr[min_idx], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Selection Sort'] = (selection_sort, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(selection_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Insertion Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Stabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wynika to stąd, że dany element, który jest mniejszy od poprzedniego (przy sortowaniu w kolejności malejącej - większy od poprzedniego) przesuwamy w lewo, dopóki jest on mniejszy (większy) od elementu, który go w danym momencie poprzedza. Dlatego, jeżeli zdarzy się kilka elementów, które mają ten sam klucz, według którego przeprowadzamy sortowanie, przesuwany element wstawiony zostanie za ostatnim elementem, którego klucz jest taki sam jak klucz elementu, który przemieszczamy, więc nie istnieje możliwość wzajemnej zmiany kolejności elementów, które posiadają ten sam klucz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Insertion Sort'] = (insertion_sort, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(insertion_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorytmy o złożoności $ O(n \\cdot log(n)) $\n",
    "### Najszybsze uniwersalne (do sortowania danych dowolnego typu o dowolnym rozkładzie z dowolnego zakresu)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n \\cdot log(n)) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n \\cdot log(n)) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Stabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ponieważ zawsze iterujemy przez elementy tablicy (lub jej fragmentów) w kolejności od lewej strony do prawej, a zamiana kolejności elementów występuje wyłącznie podczas łączenia dwóch fragmentów tablic w jedną posortowaną (funkcja $ merge $) i polega na tym, że najpierw do tablicy wynikowej przepisujemy ten element z jednej z tablic, który jest nie większy niż ten z drugiej z tablic, nie istnieje możliwość wzajemnej zamiany kolejności elementów o tych samych kluczach (jeżeli oba porównywane elementy z obu tablic mają taki sam klucz, w funkcji złączającej dwie tablice zawsze podjęta zostanie ta sama decyzja, dotycząca wyboru pierwszego przepisanego elementu, np. pierwszy będzie ten z pierwszej z tablic, a ponieważ zawsze będzie obowiązywała taka sama zasada, nie ma możliwości zamiany kolejności tych elementów względem początkowej)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Nie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1 \n",
    "#### (zwraca nową sekwencję) (NAJGORSZA implementacja - tworzy kopie fragmentów tablicy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sort(arr):\n",
    "    if len(arr) <= 1: return arr\n",
    "\n",
    "    mid_idx = len(arr) // 2\n",
    "    # Sort recursively a left and a right part of an array\n",
    "    left = merge_sort(arr[:mid_idx])\n",
    "    right = merge_sort(arr[mid_idx:])\n",
    "\n",
    "    # Return a merged array\n",
    "    return _merged(left, right)\n",
    "\n",
    "\n",
    "def _merged(left, right):\n",
    "    result = []\n",
    "    left_idx = right_idx = 0\n",
    "\n",
    "    # Rewrite values in a right (non-descending) order\n",
    "    while left_idx < len(left) and right_idx < len(right):\n",
    "        if left[left_idx] < right[right_idx]:\n",
    "            result.append(left[left_idx])\n",
    "            left_idx += 1\n",
    "        else:\n",
    "            result.append(right[right_idx])\n",
    "            right_idx += 1\n",
    "\n",
    "    # Rewrite remaining values if there are some in one of the parts\n",
    "    for i in range(left_idx, len(left)):\n",
    "        result.append(left[i])\n",
    "\n",
    "    for i in range(right_idx, len(right)):\n",
    "        result.append(right[i])\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Merge Sort (#1)'] = (merge_sort, {\n",
    "    '_merged': _merged\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(merge_sort, samples=100, modifies_arr=False, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2 \n",
    "#### (modyfikuje sortowaną sekwencję) (o dziwo nawet wolniejsza implementacja niż powyższa - przekazuje indeksy a nie tablice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sort(arr):\n",
    "    # _sort takes left_idx inclusive and right_idx exclusive\n",
    "    # (same as Python's range function does)\n",
    "    def _sort(left_idx, right_idx):\n",
    "        # If there are less than 2 elements in a part, do nothing\n",
    "        if right_idx - left_idx < 2: return\n",
    "                \n",
    "        mid_idx = (left_idx + right_idx) // 2\n",
    "        _sort(left_idx, mid_idx)\n",
    "        _sort(mid_idx, right_idx)\n",
    "        merge(left_idx, mid_idx, right_idx)\n",
    "    \n",
    "    def merge(i, j, right_end):\n",
    "        left_begin = i\n",
    "        left_end = j\n",
    "        merged = []\n",
    "        \n",
    "        while i < left_end and j < right_end:\n",
    "            if arr[i] < arr[j]:\n",
    "                merged.append(arr[i])\n",
    "                i += 1\n",
    "            else:\n",
    "                merged.append(arr[j])\n",
    "                j += 1\n",
    "        \n",
    "        for i in range(i, left_end):\n",
    "            merged.append(arr[i])\n",
    "            \n",
    "        for j in range(j, right_end):\n",
    "            merged.append(arr[j])\n",
    "            \n",
    "        idx = left_begin\n",
    "        for val in merged:\n",
    "            arr[idx] = val\n",
    "            idx += 1\n",
    "            \n",
    "    _sort(0, len(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Merge Sort (#2)'] = (merge_sort, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(merge_sort, samples=100, modifies_arr=True, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #3 \n",
    "#### (zwraca nową sekwencję) (najlepsza implementacja - nie trzeba alokować co chwilę nowych tablic oraz niepotrzebnie kilka razy przepisywać wartości) (wersja bez rekurencji)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sort(arr):\n",
    "    temp_arr = [None] * len(arr)\n",
    "    step = 1\n",
    "\n",
    "    while step < len(arr):\n",
    "        for left_idx in range(0, len(arr)-step, 2 * step):\n",
    "            mid_idx = left_idx + step\n",
    "            right_idx = mid_idx + step\n",
    "\n",
    "            if right_idx > len(arr): right_idx = len(arr)\n",
    "\n",
    "            # Perform merging\n",
    "            i = left_idx\n",
    "            j = mid_idx\n",
    "            k = left_idx\n",
    "\n",
    "            while i < mid_idx and j < right_idx:\n",
    "                if arr[i] <= arr[j]:\n",
    "                    temp_arr[k] = arr[i]\n",
    "                    i += 1\n",
    "                else:\n",
    "                    temp_arr[k] = arr[j]\n",
    "                    j += 1\n",
    "                k += 1\n",
    "\n",
    "            # Rewrite the remaining values\n",
    "            for i in range(i, mid_idx):\n",
    "                temp_arr[k] = arr[i]\n",
    "                k += 1\n",
    "\n",
    "            for j in range(j, right_idx):\n",
    "                temp_arr[k] = arr[j]\n",
    "                k += 1\n",
    "\n",
    "        # If there are still some values remaining, rewrite them\n",
    "        for k in range(k, len(arr)):\n",
    "            temp_arr[k] = arr[k]\n",
    "\n",
    "        # Swap arrays\n",
    "        arr, temp_arr = temp_arr, arr\n",
    "        step *= 2\n",
    "\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Merge Sort (#3)'] = (merge_sort, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(merge_sort, samples=100, modifies_arr=False, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Heap Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heap Sort polega na zbudowaniu KOMPLETNEGO drzewa binarnego z kolejnych wartości, jakie znajdują się w sortowanej sekwencji (tablicy), a dokładniej struktury, która nazywa się Max Heap, a następnie odczycie kolejnych największych wartości z pozostałej części struktury i przenoszeniu wartości już posortowanych na koniec sekwencji (tablicy). Budowa struktury jest szybka, a jej złożoność czasowa wynosi $ O(n) $, natomiast sam odczyt wartości z \"Maksymalnego Kopca\" (Max Heap) wymaga już wykonania $ O(n \\cdot log(n)) $ operacji. Wynika to stąd, że za każdym razem ściągamy wartość z korzenia kopca (kompletnego drzewa binarnego), tym samym \"psując\" kopiec. W miejsce usuniętej wartości wstawiamy dowolną wartość (najlepiej ostatni z liści), a następnie naprawiamy drzewo w czasie $ O(log(n)) $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dokładniejsze wyjaśnienie sposobu działania algorytmu oraz funkcjonowania samej struktury, jaką jest Heap, znajduje się poniżej:\n",
    "###### Binary Heap: https://www.youtube.com/watch?v=g9YK6sftDi0\n",
    "###### Heap Sort:  https://www.youtube.com/watch?v=k72DtCnY4MU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Warto jeszcze nadmienić, że Binary Heap nie wymaga tworzenia drzewa binarnego, ani korzystania z jakichkolwiek pomocniczych struktur. Wszystkie operacje można przeprowadzić bezpośrednio na tablicy, jedynie korzystając z tablicy jako odpowiedniej reprezentacji wartości zapisanych w \"kopcu\". Mimo to, Heap Sort zaliczany jest do najwolniejszych algorytmów sortowania (jest najwolniejszy z omawianych algorytmów o złożoności $ O(n \\cdot log(n)) $ - patrz testy na końcu pliku)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grafika z Cormena:\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n \\cdot log(n)) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n \\cdot log(n)) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(1) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Niestabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1 \n",
    "#### (z użyciem klasy do reprezentacji struktury Max Heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MaxHeap:\n",
    "    def __init__(self, values=None):\n",
    "        self.heap = values  # We don't make a copy of these values\n",
    "        self.build_heap()\n",
    "        \n",
    "    @property\n",
    "    def heap_size(self):\n",
    "        return len(self.heap)\n",
    "    \n",
    "    @staticmethod\n",
    "    def left_child_idx(curr_idx):\n",
    "        return curr_idx * 2 + 1\n",
    "    \n",
    "    @staticmethod\n",
    "    def right_child_idx(curr_idx):\n",
    "        return curr_idx * 2 + 2\n",
    "    \n",
    "    def swap(self, i, j):\n",
    "        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]\n",
    "        \n",
    "    def max_heapify(self, curr_idx, end_idx):  # O(log n)\n",
    "        # Loop till the current node has a child larger than itself\n",
    "        # We assume that when we enter a node which both children are\n",
    "        # smaller than this node, a subtree which a current node is a\n",
    "        # root of must fulfill a max-heap property.\n",
    "        while True:\n",
    "            l = self.left_child_idx(curr_idx)\n",
    "            r = self.right_child_idx(curr_idx)\n",
    "            largest_idx = curr_idx\n",
    "\n",
    "            if l < end_idx:\n",
    "                if self.heap[l] > self.heap[curr_idx]: \n",
    "                    largest_idx = l\n",
    "                if r < end_idx and self.heap[r] > self.heap[largest_idx]:\n",
    "                    largest_idx = r\n",
    "\n",
    "            if largest_idx != curr_idx:\n",
    "                self.swap(curr_idx, largest_idx)\n",
    "                curr_idx = largest_idx\n",
    "            else:\n",
    "                break\n",
    "        \n",
    "    def build_heap(self):  # O (n)\n",
    "        for i in range((self.heap_size - 1) // 2, -1, -1):\n",
    "            self.max_heapify(i, self.heap_size)\n",
    "            \n",
    "            \n",
    "def heap_sort(arr):\n",
    "    max_heap = MaxHeap(arr)\n",
    "    # Swap the currently greatest value (a heap's root) with a value\n",
    "    # stored at index i in an array representing a heap and fix\n",
    "    # a heap after doing such a change.\n",
    "    for i in range(len(arr)-1, 0, -1):\n",
    "        arr[0], arr[i] = arr[i], arr[0]\n",
    "        # Fix a heap\n",
    "        max_heap.max_heapify(0, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Heap Sort (#1)'] = (heap_sort, {'MaxHeap': MaxHeap})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Funkcja do wizualizacji drzew (tu: struktury Max Heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_heap(values):\n",
    "    if values:\n",
    "        just = 0\n",
    "        data = []\n",
    "\n",
    "        limit = 1\n",
    "        values_row = []\n",
    "        branches_row = []\n",
    "        prev_nodes = 0\n",
    "\n",
    "        for i in range(1, len(values) + 1):\n",
    "            curr_nodes = i - prev_nodes\n",
    "            val_str = str(values[i-1])\n",
    "            just = max(just, len(val_str))\n",
    "            values_row.append(val_str)\n",
    "            right_child_idx = 2 * i\n",
    "            left_child_idx = right_child_idx - 1\n",
    "            if left_child_idx < len(values):\n",
    "                branches_row.append('/')\n",
    "            if right_child_idx < len(values):\n",
    "                branches_row.append('\\\\')\n",
    "\n",
    "            if curr_nodes == limit: \n",
    "                prev_nodes = i\n",
    "                limit *= 2\n",
    "                data.append([values_row, branches_row])\n",
    "                values_row = []\n",
    "                branches_row = []\n",
    "\n",
    "        if values_row:\n",
    "            data.append([values_row, branches_row])\n",
    "\n",
    "        begin_sep = sep = 3 if just % 2 else 2\n",
    "        data_iter = iter(data[::-1])\n",
    "        result = [''] * (len(data) * 2 - 1)\n",
    "        result[-1] = (' ' * sep).join(val.center(just) for val in next(data_iter)[0])\n",
    "\n",
    "        # Format the tree string\n",
    "        for i, (values, branches) in enumerate(data_iter):\n",
    "            mul = 2 * i + 1\n",
    "            # Values\n",
    "            indent = (2 ** (i + 1) - 1) * (just + begin_sep) // 2\n",
    "            sep = 2 * sep + just\n",
    "            result[-(mul + 2)] = f\"{' ' * indent}{(' ' * sep).join(val.center(just) for val in values)}\"\n",
    "            # Branches\n",
    "            branch_indent = (3 * indent + just) // 4\n",
    "            branches_row = []\n",
    "            d_indent = indent - branch_indent\n",
    "            branches_sep = ' ' * (2 * (d_indent - 1) + just)\n",
    "            for i in range(0, len(branches), 2):\n",
    "                branches_row.append(f\"{branches[i]}{branches_sep}{branches[i + 1] if i + 1 < len(branches) else ''}\")\n",
    "            result[-(mul + 1)] = f\"{' ' * branch_indent}{(' ' * (sep - 2 * d_indent)).join(branches_row)}\"\n",
    "\n",
    "        print('\\n'.join(result))\n",
    "    else:\n",
    "        print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST #1:\n",
      "Before sorting: [-80.6, -72.5, -32.8, 53.5]\n",
      "After sorting: [-80.6, -72.5, -32.8, 53.5]\n",
      "Expected result: [-80.6, -72.5, -32.8, 53.5]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 1/1\n",
      "========== Additional results after sorting  ==========\n",
      "            -80.6\n",
      "          /       \\\n",
      "    -72.5           -32.8\n",
      "    /   \n",
      " 53.5\n",
      "\n",
      "TEST #2:\n",
      "Before sorting: [-62.0, 97.4, 0.8, 70.1, -63.3, -94.7, 98.6, -22.1, 90.8]\n",
      "After sorting: [-94.7, -63.3, -62.0, -22.1, 0.8, 70.1, 90.8, 97.4, 98.6]\n",
      "Expected result: [-94.7, -63.3, -62.0, -22.1, 0.8, 70.1, 90.8, 97.4, 98.6]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 2/2\n",
      "========== Additional results after sorting  ==========\n",
      "                            -94.7\n",
      "                      /               \\\n",
      "            -63.3                           -62.0\n",
      "          /       \\                       /       \\\n",
      "    -22.1            0.8             70.1            90.8\n",
      "    /   \\\n",
      " 97.4    98.6\n",
      "\n",
      "TEST #3:\n",
      "Before sorting: [53.0, 10.9, 38.5, 23.4, 85.8, 94.3, -14.1, -55.0, 34.7, -29.5, -41.3, 11.9]\n",
      "After sorting: [-55.0, -41.3, -29.5, -14.1, 10.9, 11.9, 23.4, 34.7, 38.5, 53.0, 85.8, 94.3]\n",
      "Expected result: [-55.0, -41.3, -29.5, -14.1, 10.9, 11.9, 23.4, 34.7, 38.5, 53.0, 85.8, 94.3]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 3/3\n",
      "========== Additional results after sorting  ==========\n",
      "                            -55.0\n",
      "                      /               \\\n",
      "            -41.3                           -29.5\n",
      "          /       \\                       /       \\\n",
      "    -14.1            10.9            11.9            23.4\n",
      "    /   \\           /   \\           /   \n",
      " 34.7    38.5    53.0    85.8    94.3\n",
      "\n",
      "Sorting algorithm is correct\n",
      "Passed tests in total: 3/3\n"
     ]
    }
   ],
   "source": [
    "test_sort(heap_sort, samples=3, val_counts=(0, 31), print_out_fn=print_heap, ints_only=False, round_=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2\n",
    "#### (jedynie z użyciem funkcji)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "_left = lambda i: 2 * i + 1\n",
    "_right = lambda i: 2 * i + 2\n",
    "\n",
    "\n",
    "def max_heapify(arr, curr_idx, end_idx):\n",
    "    # Loop till the current node has a child larger than itself\n",
    "    # We assume that when we enter a node which both children are\n",
    "    # smaller than this node, a subtree which a current node is a\n",
    "    # root of must fulfill a max-heap property.\n",
    "    while True:\n",
    "        i = _left(curr_idx)\n",
    "        j = _right(curr_idx)\n",
    "        k = curr_idx\n",
    "        \n",
    "        if i < end_idx:\n",
    "            if arr[i] > arr[k]:\n",
    "                k = i\n",
    "            if j < end_idx and arr[j] > arr[k]:\n",
    "                k = j\n",
    "                \n",
    "        if k == curr_idx: return\n",
    "        # Swap the current with the largest child\n",
    "        arr[curr_idx], arr[k] = arr[k], arr[curr_idx]\n",
    "        curr_idx = k\n",
    "\n",
    "        \n",
    "def build_heap(arr):\n",
    "    for i in range((len(arr) - 1) // 2, -1, -1):\n",
    "        max_heapify(arr, i, len(arr))\n",
    "\n",
    "        \n",
    "def heap_sort(arr):\n",
    "    build_heap(arr)\n",
    "    # Swap the currently greatest value (a heap's root) with a value\n",
    "    # stored on index i in an array representing a heap and fix\n",
    "    # a heap after doing such a change.\n",
    "    for i in range(len(arr)-1, 0, -1):\n",
    "        arr[0], arr[i] = arr[i], arr[0]\n",
    "        # Fix a heap\n",
    "        max_heapify(arr, 0, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Heap Sort (#2)'] = (heap_sort, {\n",
    "    'max_heapify': max_heapify,\n",
    "    'build_heap': build_heap,\n",
    "    '_left': _left,\n",
    "    '_right': _right\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST #1:\n",
      "Before sorting: [58.62, -89.78, -46.01, 62.38, -7.21, -82.29, 89.96, 33.51, 93.59, 97.62, -50.54, 47.86, 20.83, 24.92, -5.11, -69.63, 16.39, 70.56, 51.63, -53.97, 33.76]\n",
      "After sorting: [-89.78, -82.29, -69.63, -53.97, -50.54, -46.01, -7.21, -5.11, 16.39, 20.83, 24.92, 33.51, 33.76, 47.86, 51.63, 58.62, 62.38, 70.56, 89.96, 93.59, 97.62]\n",
      "Expected result: [-89.78, -82.29, -69.63, -53.97, -50.54, -46.01, -7.21, -5.11, 16.39, 20.83, 24.92, 33.51, 33.76, 47.86, 51.63, 58.62, 62.38, 70.56, 89.96, 93.59, 97.62]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 1/1\n",
      "========== Additional results after sorting  ==========\n",
      "                                                            -89.78\n",
      "                                              /                                \\\n",
      "                            -82.29                                                          -69.63\n",
      "                      /                \\                                              /                \\\n",
      "            -53.97                          -50.54                          -46.01                          -7.21 \n",
      "          /        \\                      /        \\                      /        \\                      /        \\\n",
      "    -5.11           16.39           20.83           24.92           33.51           33.76           47.86           51.63 \n",
      "    /    \\          /    \\          /    \\\n",
      "58.62   62.38   70.56   89.96   93.59   97.62 \n",
      "\n",
      "TEST #2:\n",
      "Before sorting: [91.38, 97.03, 61.3, -37.12, 33.36, 31.79, -55.66, -57.71, 4.28, 41.31, -53.89, 98.56, 18.6, 9.39, -49.4, -78.7, 43.12, -0.57]\n",
      "After sorting: [-78.7, -57.71, -55.66, -53.89, -49.4, -37.12, -0.57, 4.28, 9.39, 18.6, 31.79, 33.36, 41.31, 43.12, 61.3, 91.38, 97.03, 98.56]\n",
      "Expected result: [-78.7, -57.71, -55.66, -53.89, -49.4, -37.12, -0.57, 4.28, 9.39, 18.6, 31.79, 33.36, 41.31, 43.12, 61.3, 91.38, 97.03, 98.56]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 2/2\n",
      "========== Additional results after sorting  ==========\n",
      "                                                            -78.7 \n",
      "                                              /                                \\\n",
      "                            -57.71                                                          -55.66\n",
      "                      /                \\                                              /                \\\n",
      "            -53.89                          -49.4                           -37.12                          -0.57 \n",
      "          /        \\                      /        \\                      /        \\                      /        \\\n",
      "     4.28            9.39            18.6           31.79           33.36           41.31           43.12            61.3 \n",
      "    /    \\          /    \n",
      "91.38   97.03   98.56 \n",
      "\n",
      "TEST #3:\n",
      "Before sorting: [-43.82, -5.24, 82.63, -13.29, 87.51, 4.37, 6.21, -92.77, -63.24, 73.83, -81.81, -59.47, 31.92, -6.41, -12.99, 86.53, 70.32, 34.85, 99.16, 87.95, -68.06, -79.13, -69.73, 46.29, 47.46, -34.67, -25.62, 59.2, 90.95, 71.96]\n",
      "After sorting: [-92.77, -81.81, -79.13, -69.73, -68.06, -63.24, -59.47, -43.82, -34.67, -25.62, -13.29, -12.99, -6.41, -5.24, 4.37, 6.21, 31.92, 34.85, 46.29, 47.46, 59.2, 70.32, 71.96, 73.83, 82.63, 86.53, 87.51, 87.95, 90.95, 99.16]\n",
      "Expected result: [-92.77, -81.81, -79.13, -69.73, -68.06, -63.24, -59.47, -43.82, -34.67, -25.62, -13.29, -12.99, -6.41, -5.24, 4.37, 6.21, 31.92, 34.85, 46.29, 47.46, 59.2, 70.32, 71.96, 73.83, 82.63, 86.53, 87.51, 87.95, 90.95, 99.16]\n",
      "Test PASSED\n",
      "Current passed-to-tested ratio: 3/3\n",
      "========== Additional results after sorting  ==========\n",
      "                                                            -92.77\n",
      "                                              /                                \\\n",
      "                            -81.81                                                          -79.13\n",
      "                      /                \\                                              /                \\\n",
      "            -69.73                          -68.06                          -63.24                          -59.47\n",
      "          /        \\                      /        \\                      /        \\                      /        \\\n",
      "    -43.82          -34.67          -25.62          -13.29          -12.99          -6.41           -5.24            4.37 \n",
      "    /    \\          /    \\          /    \\          /    \\          /    \\          /    \\          /    \\          /    \n",
      " 6.21   31.92   34.85   46.29   47.46    59.2   70.32   71.96   73.83   82.63   86.53   87.51   87.95   90.95   99.16 \n",
      "\n",
      "Sorting algorithm is correct\n",
      "Passed tests in total: 3/3\n"
     ]
    }
   ],
   "source": [
    "test_sort(heap_sort, samples=3, val_counts=[0, 31], print_out_fn=print_heap, ints_only=False, round_=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $\n",
    "##### lub: $ O(n \\cdot log(n)) $ przy skorzystaniu z wyboru pivota przy pomocy algorytmu Mediana Median (zwanego dla $ k = 5 $, gdzie $ k $ - liczebność grup, na które dzielimy tablicę, \"Magiczne Piątki\")\n",
    "###### UWAGA: W tym przypadku można zauważyć, że fakt iż algorytm z użyciem Magicznych Piątek ma niższą najgorszą złożoność czasową i taką zamą złożoność oczekiwaną, nie świadczy wcale o jego szybszym działaniu. W większości przypadków, gdy otrzymujemy dane, które nie są posortowane, zauważymy spadek wydajności, ponieważ zawsze konieczne jest wyznaczenie dodatkowo mediany median, która w danym przypadku nic nie poprawia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n \\cdot log(n)) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n) $\n",
    "Jedynie dla niezoptymalizowanych pod kątem pamięci implementacji (są to 3 pierwsze implementacje niżej, kolejne już tylko wymagają $ O(log(n)) $ pamięci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### O(log(n))\n",
    "Zazwyczaj ten algorytm sortowania ma taką złożoność pamięciową. Można go zaimplementować w taki sposób, że $ O(lon(n)) $ jest jednocześnie jego średnią oraz najgorszą złożonością pamięciową (patrz implementacja #4 i kolejne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Niestabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Tak (przy założeniu, że pamięć, jaką zajmuje stos rekurencyjny, wliczamy do złożoności)\n",
    "Głosy są podzielone. Niby nie rezerwujemy pamięci w sposób jawny w celu tymczasowego przechowywania częściowo posortowanych danych, ale jednak złożoność pamięciowa algorytmu nie wynosi $ O(1) $, ponieważ zmienne przechowywane na stosie rekurencyjnym również zajmują pamięć, więc stwierdzenie, czy sortowanie odbywa się w miejscu, zależy od tego, jak na to spojrzymy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1\n",
    "#### (Wersja rekurencyjna ze sztywno ustalonym pivotem - my wybieramy ostatni element tablicy - z wykorzystaniem algorytmu podziału zaproponowanego przez Lomuto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = partition(arr, left_idx, right_idx)\n",
    "        _quick_sort(arr, left_idx, pivot_position - 1)\n",
    "        left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        \n",
    "''' Bez usuwania rekursji ogonowej, algorytm wygląda następująco: '''\n",
    "#     if left_idx < right_idx:\n",
    "#         pivot_position = partition(arr, left_idx, right_idx)\n",
    "#         _quick_sort(arr, left_idx, pivot_position - 1)\n",
    "#         _quick_sort(arr, pivot_position + 1, right_idx)\n",
    "        \n",
    "        \n",
    "def partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[right_idx]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than\n",
    "    # pivot and of elements greater than a pivot\n",
    "    i = left_idx\n",
    "    for j in range(left_idx, right_idx):\n",
    "        if arr[j] < pivot:\n",
    "            swap(arr, i, j)\n",
    "            i += 1\n",
    "    \n",
    "    # Place a pivot element on its destination index\n",
    "    swap(arr, i, right_idx)\n",
    "    \n",
    "    return i  # Return a pivot position after the last swap\n",
    "    \n",
    "    \n",
    "def swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#1 - Lomuto parition)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    'partition': partition,\n",
    "    'swap': swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2\n",
    "#### (Wersja rekurencyjna ze sztywno ustalonym pivotem - korzysta z algorytmu Hoare’a podziału tablicy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### UWAGA:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O ile w implementacji funkcji partition zaproponowanej przez Lomuto mamy pewność, że po podziale, pivot znajduje się na swojej końcowej pozycji, tj. wyznaczyliśmy jego położenie końcowe w posortowanej tablicy, więc w kolejnych iteracjach sortujemy pozostałe części tablicy z pominięciem pivota, tak w implementacji funkcji podziału Hoare'a, wiemy jedynie, że pivot znajduje się pod koniec na zwróconej przez funkcję partition pozycji i należy do części tablicy, składającej się z elementów od niego mniejszych i mu równych. Nie oznacza to, że pivot znalazł się na swojej końcowej pozycji, więc musimy posortować lewą część tablicy wraz z pivotem oraz prawą (bez pivota)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = partition(arr, left_idx, right_idx)\n",
    "        _quick_sort(arr, left_idx, pivot_position),  '<- zamiast pivot_position + 1 jest samo pivot_position'\n",
    "        left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        \n",
    "''' Funkcja partition jest zmieniona: '''     \n",
    "def partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[left_idx]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "''' Koniec funkcji partition ''' \n",
    "    \n",
    "def swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#2 - Hoare\\'s partition)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    'partition': partition,\n",
    "    'swap': swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #3\n",
    "#### (Wersja rekurencyjna z losowo wybieranym pivotem - korzystamy z funkcji partition Hoare'a, ponieważ jest nieco szybsza od wersji Lomuto (nie wykonuje niepotrzebnych zamian elementów))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = partition(arr, left_idx, right_idx)\n",
    "        _quick_sort(arr, left_idx, pivot_position)\n",
    "        left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        \n",
    "        \n",
    "def partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[random.randint(left_idx, right_idx)]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#3 - random pivot)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    'partition': partition,\n",
    "    'swap': swap\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #4\n",
    "#### (Wersja rekurencyjna z losowo wybieranym pivotem, która zajmuje tylko $ O(log n) $ dodatkowej pamięci - na wywołania rekurencyjne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = _partition(arr, left_idx, right_idx)\n",
    "        \n",
    "        ''' Zmiany poniżej: '''\n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            _quick_sort(arr, left_idx, pivot_position)\n",
    "            left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        else:\n",
    "            _quick_sort(arr, pivot_position + 1, right_idx)\n",
    "            right_idx = pivot_position  # I removed a tailing recursion\n",
    "        ''' Koniec zmian '''\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[random.randint(left_idx, right_idx)]\n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            _swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#4 - O(log n) memory)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #5\n",
    "#### (Wersja iteracyjna z użyciem stosu o stałym rozmiarze (jako stos używamy tabicę o długości $ log_2(n) $). Jest to zoptymalizowana pamięciowo i wydajnościowo wersja algorytmu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    if len(arr) < 2: return\n",
    "    stack = [None] * math.ceil(math.log(len(arr), 2))\n",
    "    stack_idx = 0  # An index of the last element in a stack\n",
    "    stack[0] = (0, len(arr) - 1)\n",
    "    \n",
    "    while stack_idx >= 0:\n",
    "#         print(stack)\n",
    "        # Take the last indices pair out of stack\n",
    "        left_idx, right_idx = stack[stack_idx]\n",
    "        stack[stack_idx] = None\n",
    "        stack_idx -= 1\n",
    "        \n",
    "        pivot_position = _partition(arr, left_idx, right_idx)\n",
    "\n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            # Store indices of the longer part at first if has at least 2 elements\n",
    "            if pivot_position + 1 < right_idx:\n",
    "                stack_idx += 1\n",
    "                stack[stack_idx] = (pivot_position + 1, right_idx)\n",
    "            # Then store indices of a shorter part (as it will produce less parts after sorting) (if has at least 2 elements)\n",
    "            if left_idx < pivot_position:\n",
    "                stack_idx += 1\n",
    "                stack[stack_idx] = (left_idx, pivot_position)\n",
    "        else:\n",
    "            # Store indices of the longer part at first if has at least 2 elements\n",
    "            if left_idx < pivot_position:\n",
    "                stack_idx += 1\n",
    "                stack[stack_idx] = (left_idx, pivot_position)\n",
    "            # Then store indices of a shorter part (as it will produce less parts after sorting) (if has at least 2 elements)\n",
    "            if pivot_position + 1 < right_idx:\n",
    "                stack_idx += 1\n",
    "                stack[stack_idx] = (pivot_position + 1, right_idx)\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[random.randint(left_idx, right_idx)]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            _swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#5 - static stack)'] = (quick_sort, {\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #6\n",
    "#### (Wersja iteracyjna z użyciem stosu o dynamicznym rozmiarze (działa jak wyżej, ale korzysta z metod .append() i .pop() Pythonowych list). Jest to zoptymalizowana pamięciowo i wydajnościowo wersja algorytmu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    if len(arr) < 2: return\n",
    "    stack = [(0, len(arr)-1)]\n",
    "    \n",
    "    while stack:\n",
    "#         print(stack)\n",
    "        # Take the last indices pair out of the stack\n",
    "        left_idx, right_idx = stack.pop()\n",
    "        \n",
    "        pivot_position = _partition(arr, left_idx, right_idx)\n",
    "\n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            # Store indices of the longer part at first if has at least 2 elements\n",
    "            if pivot_position + 1 < right_idx:\n",
    "                stack.append((pivot_position + 1, right_idx))\n",
    "                # Then store indices of a shorter part (as it will produce less parts after sorting)\n",
    "                # (if has at least 2 elements and we are sure the longer part has also at least 2 elements)\n",
    "                if left_idx < pivot_position:\n",
    "                    stack.append((left_idx, pivot_position))\n",
    "        else:\n",
    "            # Store indices of the longer part at first if has at least 2 elements\n",
    "            if left_idx < pivot_position:\n",
    "                stack.append((left_idx, pivot_position))\n",
    "                # Then store indices of a shorter part (as it will produce less parts after sorting)\n",
    "                # (if has at least 2 elements and we are sure the longer part has also at least 2 elements)\n",
    "                if pivot_position + 1 < right_idx:\n",
    "                    stack.append((pivot_position + 1, right_idx))\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[random.randint(left_idx, right_idx)]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            _swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#6 - dynamic stack)'] = (quick_sort, {\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)\n",
    "# test_sort(quick_sort, range_=(-100_000, 100_000), val_counts=(0, 10_000), samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #7\n",
    "#### (Wersja rekurencyjna z pivotem wybieranym przy pomocy algorytmu Magiczne Piątki, która zajmuje tylko $ O(log(n)) $ dodatkowej pamięci - na wywołania rekurencyjne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = _partition(arr, left_idx, right_idx)\n",
    "\n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            _quick_sort(arr, left_idx, pivot_position)\n",
    "            left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        else:\n",
    "            _quick_sort(arr, pivot_position + 1, right_idx)\n",
    "            right_idx = pivot_position  # I removed a tailing recursion\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    # Use a median of medians algorithm to select a pivot value\n",
    "    pivot = median_of_medians(arr, left_idx, right_idx)\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            _swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]\n",
    "    \n",
    "    \n",
    "def median_of_medians(arr, left_idx, right_idx, k=5):\n",
    "    # Store the position on which the next median will be stored\n",
    "    # (we will store each median of current k-element subarrays one\n",
    "    # after another at the beginning of the subarray which begins\n",
    "    # on the left_index and ends on the right_idx (inclusive)\n",
    "    next_swap_idx = left_idx\n",
    "\n",
    "    # Loop till the current subarray has more than k elements\n",
    "    while right_idx - left_idx >= k:\n",
    "        # Calculate and store a median of each full k-element subarray\n",
    "        for end_idx in range(left_idx + k-1, right_idx + 1, k):\n",
    "            # Store a median on the next index just after the last median stored\n",
    "            # (swap a median with a value placed after previously calculated medians)\n",
    "            _swap(arr, next_swap_idx, _select_median(arr, end_idx - k + 1, end_idx))\n",
    "            next_swap_idx += 1\n",
    "\n",
    "        # Calculate and store a median of the remaining subarray\n",
    "        # (which has less than k elements)\n",
    "        if end_idx < right_idx - 1:\n",
    "            _swap(arr, next_swap_idx, _select_median(arr, end_idx, right_idx))\n",
    "            next_swap_idx += 1\n",
    "\n",
    "        # Prepare variables for the next loop (we will calculate a median of\n",
    "        # the subarray of medians calculated above, so the right_idx will now\n",
    "        # be equal to the index of the last median previously determined)\n",
    "        right_idx = next_swap_idx - 1\n",
    "        next_swap_idx = left_idx\n",
    "\n",
    "    # Return a value of a median\n",
    "    return arr[_select_median(arr, left_idx, right_idx)]\n",
    "\n",
    "\n",
    "def _select_median(arr, left_idx, right_idx):\n",
    "    # Using the Selection Sort concept, sort only elements of the\n",
    "    # subarray which are placed up to the middle index (including\n",
    "    # the middle element)\n",
    "    mid_idx = (right_idx + left_idx) // 2\n",
    "    for i in range(left_idx, mid_idx + 1):\n",
    "        min_idx = i\n",
    "        for j in range(i + 1, right_idx + 1):\n",
    "            if arr[j] < arr[min_idx]:\n",
    "                min_idx = j\n",
    "        _swap(arr, min_idx, i)\n",
    "    # Return the middle index which is a position of the median\n",
    "    # after sorting a part of the subarray\n",
    "    return mid_idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#7 - median of medians pivot)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap,\n",
    "    'median_of_medians': median_of_medians,\n",
    "    '_select_median': _select_median\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(quick_sort, samples=10000, val_counts=(0, 1000), failed_only=True)\n",
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #8\n",
    "#### (Wersja rekurencyjna ze sztywno ustalonym pivotem, która zajmuje tylko $ O(log(n)) $ dodatkowej pamięci - na wywołania rekurencyjne, pozwalająca na sortowanie dowolnych danych według zdefiniowanych przez własną funkcję wartości)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Domyślnie funkcja, według której odbywa się sortowanie, sortuje elementy po nich samych (tzn. odbywa się tradycyjne sortowanie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quick_sort(arr, *, fn=lambda x: x):\n",
    "    _quick_sort(arr, 0, len(arr) - 1, fn)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx, fn):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = _partition(arr, left_idx, right_idx, fn)\n",
    "\n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            _quick_sort(arr, left_idx, pivot_position - 1, fn)\n",
    "            left_idx = pivot_position + 1\n",
    "        else:\n",
    "            _quick_sort(arr, pivot_position + 1, right_idx, fn)\n",
    "            right_idx = pivot_position - 1\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx, fn):\n",
    "    pivot = fn(arr[right_idx])\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than\n",
    "    # pivot and of elements greater than a pivot\n",
    "    i = left_idx\n",
    "    for j in range(left_idx, right_idx):\n",
    "        if fn(arr[j]) < pivot:\n",
    "            _swap(arr, i, j)\n",
    "            i += 1\n",
    "    \n",
    "    # Place a pivot element on its destination index\n",
    "    _swap(arr, i, right_idx)\n",
    "    \n",
    "    return i  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quick Sort (#8 - own sorting function)'] = (quick_sort, {\n",
    "    '_quick_sort': _quick_sort,\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting by absolute value:\n",
      "(should be failed because testing function checks if an array is sorted in a non-decreasing order)\n",
      "\n",
      "TEST #1:\n",
      "Before sorting: [47.16, 87.5, -95.3, 67.67, 67.69, -44.56, 39.37, -75.41, 6.72, 9.33, 15.02, 92.55, -7.13, 81.68, 67.07, -21.35, -53.68, 48.47, 13.18, -85.66, 19.47, 62.13, -80.81, -41.48, -98.61, -59.09, -1.47, 27.98, -0.53, 49.65, 59.81, 60.45, 39.0, -92.24]\n",
      "After sorting: [-0.53, -1.47, 6.72, -7.13, 9.33, 13.18, 15.02, 19.47, -21.35, 27.98, 39.0, 39.37, -41.48, -44.56, 47.16, 48.47, 49.65, -53.68, -59.09, 59.81, 60.45, 62.13, 67.07, 67.67, 67.69, -75.41, -80.81, 81.68, -85.66, 87.5, -92.24, 92.55, -95.3, -98.61]\n",
      "Expected result: [-98.61, -95.3, -92.24, -85.66, -80.81, -75.41, -59.09, -53.68, -44.56, -41.48, -21.35, -7.13, -1.47, -0.53, 6.72, 9.33, 13.18, 15.02, 19.47, 27.98, 39.0, 39.37, 47.16, 48.47, 49.65, 59.81, 60.45, 62.13, 67.07, 67.67, 67.69, 81.68, 87.5, 92.55]\n",
      "Test FAILED\n",
      "Current passed-to-tested ratio: 0/1\n",
      "\n",
      "TEST #2:\n",
      "Before sorting: [-19.96, -47.83, 85.34, 2.99, 90.33, -35.07, 74.19, 48.99, 22.95, 48.32, -88.36]\n",
      "After sorting: [2.99, -19.96, 22.95, -35.07, -47.83, 48.32, 48.99, 74.19, 85.34, -88.36, 90.33]\n",
      "Expected result: [-88.36, -47.83, -35.07, -19.96, 2.99, 22.95, 48.32, 48.99, 74.19, 85.34, 90.33]\n",
      "Test FAILED\n",
      "Current passed-to-tested ratio: 0/2\n",
      "\n",
      "TEST #3:\n",
      "Before sorting: [-23.62, 42.76, -38.18, 26.5, -50.77, -90.07, -0.11, -67.99, -51.78, 1.94, 67.49, -91.16, -48.67, -37.07, 29.15, 7.45, 96.73, 46.13, -82.52, -29.2, -84.06, -26.06, 38.4, -48.7, 98.86, -56.44, 35.47, -21.15, -59.9, 82.32, -83.94, -4.54, 40.16, 17.32, -22.38, 86.81, -36.09, 84.8, -74.29, 18.28, -78.78, 23.06, -53.34, -93.13, -81.15, 74.15]\n",
      "After sorting: [-0.11, 1.94, -4.54, 7.45, 17.32, 18.28, -21.15, -22.38, 23.06, -23.62, -26.06, 26.5, 29.15, -29.2, 35.47, -36.09, -37.07, -38.18, 38.4, 40.16, 42.76, 46.13, -48.67, -48.7, -50.77, -51.78, -53.34, -56.44, -59.9, 67.49, -67.99, 74.15, -74.29, -78.78, -81.15, 82.32, -82.52, -83.94, -84.06, 84.8, 86.81, -90.07, -91.16, -93.13, 96.73, 98.86]\n",
      "Expected result: [-93.13, -91.16, -90.07, -84.06, -83.94, -82.52, -81.15, -78.78, -74.29, -67.99, -59.9, -56.44, -53.34, -51.78, -50.77, -48.7, -48.67, -38.18, -37.07, -36.09, -29.2, -26.06, -23.62, -22.38, -21.15, -4.54, -0.11, 1.94, 7.45, 17.32, 18.28, 23.06, 26.5, 29.15, 35.47, 38.4, 40.16, 42.76, 46.13, 67.49, 74.15, 82.32, 84.8, 86.81, 96.73, 98.86]\n",
      "Test FAILED\n",
      "Current passed-to-tested ratio: 0/3\n",
      "\n",
      "Sorting algorithm is wrong\n",
      "Passed tests in total: 0/3\n",
      "\n",
      "\n",
      "These test will be passed:\n",
      "\n",
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(quick_sort, samples=10000, val_counts=(0, 1000), range_=(-10_000, 10_000),\n",
    "#           ints_only=False, failed_only=True)\n",
    "\n",
    "# The test below should be failed when there are nagative numbers in a sorted array\n",
    "print('Sorting by absolute value:')\n",
    "print('(should be failed because testing function checks if an array is sorted in a non-decreasing order)\\n')\n",
    "test_sort(lambda arr: quick_sort(arr, fn=lambda x: abs(x)), samples=3, ints_only=False, failed_only=True)\n",
    "print('\\n\\nThese test will be passed:\\n')\n",
    "test_sort(quick_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quicker Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jest to zmodyfikowana wersja algorytmu Quick Sort, dzięki czemu algorytm ten jest jeszcze szybszy, ale jedynie w przypadku, gdy w tablicy występują powtórki danej wartości. Tzn. wartość wybierana za pivota musi wystąpić przynajmniej kilka razy, abyśmy zauważyli wzrost wydajności. Jedyną różnicą względem zwykłego Quick Sorta jest idea podziału tablicy (dzielimy na 3 części, z których pierwsza zawiera elementy mniejsze od pivota, druga mu równe, a trzecia większe od niego)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $\n",
    "##### lub: $ O(n \\cdot log(n)) $ przy skorzystaniu z pivota, wybieranego przy pomocy algorytmu Mediana Median (zwanego dla $ k = 5 $, gdzie $ k $ - liczebność grup, na które dzielimy tablicę, \"Magiczne Piątki\")\n",
    "###### UWAGA: W tym przypadku można zauważyć, że fakt iż algorytm z użyciem Magicznych Piątek ma niższą najgorszą złożoność czasową i taką zamą złożoność oczekiwaną, nie świadczy wcale o jego szybszym działaniu. W większości przypadków, gdy otrzymujemy dane, które nie są posortowane, zauważymy spadek wydajności, ponieważ zawsze konieczne jest wyznaczenie dodatkowo mediany median, która w danym przypadku nic nie poprawia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n \\cdot log(log(n))) $\n",
    "Taką złożoność osiągniemy, jeżeli w tablicy będzie bardzo dużo powrarzających się wartości. (W powyższym oszacowaniu złożoności przyjmujemy, że w $ n $- elementowej tablicy znajduje się tylko $ log(n) $ różnych wartości)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Podobnie jak Quick Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Niestabilny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Ta sama zasada, co dla Quick Sorta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1\n",
    "#### (Wersja rekurencyjna z usuniętą rekursją ogonową i zoptymalizowanym wywoływaniem rekurencyjnym w taki sposób, by zużywać maksymalnie $ O(log(n)) $ miejsca na stosie rekurencyjnym)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicker_sort(arr):\n",
    "    _quicker_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quicker_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        lt_pivot_last, gt_pivot_first = _partition(arr, left_idx, right_idx)\n",
    "        \n",
    "        # If a number of elements lower tha a pivot is greater than a number\n",
    "        # of elements greater than a pivot, sort recursively the shorter part\n",
    "        # of elements which are greater than a pivot\n",
    "        if lt_pivot_last - left_idx > right_idx - gt_pivot_first:\n",
    "            _quicker_sort(arr, gt_pivot_first, right_idx)\n",
    "            right_idx = lt_pivot_last  # I removed a tailing recursion\n",
    "        # Otherwise, sort a subarray of elementslower than a pivot first\n",
    "        # as it is shorter than a subarray of elements greater than a pivot\n",
    "        else:\n",
    "            _quicker_sort(arr, left_idx, lt_pivot_last)\n",
    "            left_idx = gt_pivot_first  # I removed a tailing recursion\n",
    "\n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[left_idx]\n",
    "    \n",
    "    # Partition an array into 3 subarrays (lower than, equal to and\n",
    "    # greater than a pivot value)\n",
    "    i = left_idx     # A pointer of the first pivot\n",
    "    j = left_idx + 1 # A pointer of the element after the last pivot\n",
    "    k = j            # A pointer of the currently checked element \n",
    "    while k <= right_idx:\n",
    "        if arr[k] < pivot:\n",
    "            _two_swaps(arr, i, j, k)\n",
    "            i += 1\n",
    "            j += 1\n",
    "        elif arr[k] == pivot:\n",
    "            _one_swap(arr, j, k)\n",
    "            j += 1\n",
    "        k += 1\n",
    "        \n",
    "    # Return the last index of the subarray of elements lower than a pivot\n",
    "    # and the first index of the subarray of elements greater than a pivot\n",
    "    return i - 1, j\n",
    "\n",
    "    \n",
    "def _one_swap(arr, i, j):\n",
    "    # Swap two elements in an array\n",
    "    arr[i], arr[j] = arr[j], arr[i]\n",
    "    \n",
    "\n",
    "def _two_swaps(arr, i, j, k):\n",
    "    # Rotate right the elements of the indices specified\n",
    "    arr[k], arr[j], arr[i] = arr[j], arr[i], arr[k]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quicker Sort (#1 - recursive)'] = (quicker_sort, {\n",
    "    '_quicker_sort': _quicker_sort,\n",
    "    '_partition': _partition,\n",
    "    '_one_swap': _one_swap,\n",
    "    '_two_swaps': _two_swaps\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(quicker_sort, range_=(0, 100), val_counts=(0, 10_000), samples=1000, failed_only=True)\n",
    "# test_sort(quicker_sort, samples=3, range_=(-20, 20), val_counts=(100, 200), ints_only=True, uniform_distribution=False)\n",
    "test_sort(quicker_sort, samples=100, ints_only=False, uniform_distribution=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2\n",
    "#### (Wersja rekurencyjna ze zoptymalizowanym wybieraniem pivota jako mediany median (patrz plik z algorytmami wyszukiwania i wyboru) oraz z usuniętą rekursją ogonową i zoptymalizowanym wywoływaniem rekurencyjnym w taki sposób, by zużywać maksymalnie $ O(log(n)) $ miejsca na stosie rekurencyjnym)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poniższa implementacja rozwiązuje problem wyboru pivota, dzięki czemu zminimalizowane jest ryzyko wystąpienia najgorszego przypadku, w którym np. na wejściu dostajemy posortowaną tablicę. Dzięki temu niemożliwe jest ukwadratowienie się poniższego algorytmu sortowania."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicker_sort(arr):\n",
    "    _quicker_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quicker_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        lt_pivot_last, gt_pivot_first = _partition(arr, left_idx, right_idx)\n",
    "        \n",
    "        # If a number of elements lower tha a pivot is greater than a number\n",
    "        # of elements greater than a pivot, sort recursively the shorter part\n",
    "        # of elements which are greater than a pivot\n",
    "        if lt_pivot_last - left_idx > right_idx - gt_pivot_first:\n",
    "            _quicker_sort(arr, gt_pivot_first, right_idx)\n",
    "            right_idx = lt_pivot_last  # I removed a tailing recursion\n",
    "        # Otherwise, sort a subarray of elementslower than a pivot first\n",
    "        # as it is shorter than a subarray of elements greater than a pivot\n",
    "        else:\n",
    "            _quicker_sort(arr, left_idx, lt_pivot_last)\n",
    "            left_idx = gt_pivot_first  # I removed a tailing recursion\n",
    "\n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot_idx = median_of_medians(arr, left_idx, right_idx)\n",
    "    pivot = arr[pivot_idx]\n",
    "    # Place a pivot value in the left_idx position od af an array\n",
    "    _one_swap(arr, left_idx, pivot_idx)\n",
    "    \n",
    "    # Partition an array into 3 subarrays (lower than, equal to and\n",
    "    # greater than a pivot value)\n",
    "    i = left_idx     # A pointer of the first pivot\n",
    "    j = left_idx + 1 # A pointer of the element after the last pivot\n",
    "    k = j            # A pointer of the currently checked element \n",
    "    while k <= right_idx:\n",
    "        if arr[k] < pivot:\n",
    "            _two_swaps(arr, i, j, k)\n",
    "            i += 1\n",
    "            j += 1\n",
    "        elif arr[k] == pivot:\n",
    "            _one_swap(arr, j, k)\n",
    "            j += 1\n",
    "        k += 1\n",
    "        \n",
    "    # Return the last index of the subarray of elements lower than a pivot\n",
    "    # and the first index of the subarray of elements greater than a pivot\n",
    "    return i - 1, j\n",
    "\n",
    "    \n",
    "def _one_swap(arr, i, j):\n",
    "    # Swap two elements in an array\n",
    "    arr[i], arr[j] = arr[j], arr[i]\n",
    "    \n",
    "\n",
    "def _two_swaps(arr, i, j, k):\n",
    "    # Rotate right the elements of the indices specified\n",
    "    arr[k], arr[j], arr[i] = arr[j], arr[i], arr[k]\n",
    "    \n",
    "    \n",
    "def median_of_medians(arr, left_idx, right_idx, k=5):\n",
    "    # Store the position on which the next median will be stored\n",
    "    # (we will store each median of current k-element subarrays one\n",
    "    # after another at the beginning of the subarray which begins\n",
    "    # on the left_index and ends on the right_idx (inclusive)\n",
    "    next_swap_idx = left_idx\n",
    "\n",
    "    # Loop till the current subarray has more than k elements\n",
    "    while right_idx - left_idx >= k:\n",
    "        # Calculate and store a median of each full k-element subarray\n",
    "        for end_idx in range(left_idx + k-1, right_idx + 1, k):\n",
    "            # Store a median on the next index just after the last median stored\n",
    "            # (swap a median with a value placed after previously calculated medians)\n",
    "            _one_swap(arr, next_swap_idx, _select_median(arr, end_idx - k + 1, end_idx))\n",
    "            next_swap_idx += 1\n",
    "\n",
    "        # Calculate and store a median of the remaining subarray\n",
    "        # (which has less than k elements)\n",
    "        if end_idx < right_idx - 1:\n",
    "            _one_swap(arr, next_swap_idx, _select_median(arr, end_idx, right_idx))\n",
    "            next_swap_idx += 1\n",
    "\n",
    "        right_idx = next_swap_idx - 1\n",
    "        next_swap_idx = left_idx\n",
    "\n",
    "    # Return a value of a median\n",
    "    return _select_median(arr, left_idx, right_idx)\n",
    "\n",
    "\n",
    "def _select_median(arr, left_idx, right_idx):\n",
    "    # Using the Selection Sort concept, sort only elements of the\n",
    "    # subarray which are placed up to the middle index (including\n",
    "    # the middle element)\n",
    "    mid_idx = (right_idx + left_idx) // 2\n",
    "    for i in range(left_idx, mid_idx + 1):\n",
    "        min_idx = i\n",
    "        for j in range(i + 1, right_idx + 1):\n",
    "            if arr[j] < arr[min_idx]:\n",
    "                min_idx = j\n",
    "        _one_swap(arr, min_idx, i)\n",
    "    # Return the middle index which is a position of the median\n",
    "    # after sorting a part of the subarray\n",
    "    return mid_idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Quicker Sort (#2 - median of medians pivot)'] = (quicker_sort, {\n",
    "    '_quicker_sort': _quicker_sort,\n",
    "    '_partition': _partition,\n",
    "    '_one_swap': _one_swap,\n",
    "    '_two_swaps': _two_swaps,\n",
    "    'median_of_medians': median_of_medians,\n",
    "    '_select_median': _select_median\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(quicker_sort, samples=100, uniform_distribution=False, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorytmy o złożoności $ O(n) $\n",
    "### Poniższe algorytmy są bardzo szybkie (szybsze od wszystkich powyższych), ale jedynie wtedy, gdy spełnione są pewne założenia. W zależności od algorytmu, przyjmujemy, że będzie on sortował dane konkretnego rodzaju, o zakładanym rozkładzie lub z odpowiedniego przedziału."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counting Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Założenia, aby korzystanie z algorytmu było opłacalne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Z reguły zakładamy, że sortowane elementy to liczby całkowite z przedziału od 0 do pewnej wartości k, będącej największą wartością w sortowanej tablicy (możliwe jest oczywiście sortowanie również liczb ujemnych, przy pomocy tego algorytmu, bądź także liter (ciągów tekstowych więcej niż 1-literowych lepiej nie sortować tym sposobem), po wprowadzeniu odpowiednich modyfikacji algorytmu,\n",
    "- Counting Sort działa najlepiej dla danych, w których wiele wartości się powtarza, choć nie wpływa to znacząco na jego złożoność, która ZAWSZE zależy w największym stopniu od zakresu wartości, czyli jaka jest wartość najmniejsza i jaka największa (patrz niżej)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Każdy przypadek\n",
    "##### $ O(n + k) $\n",
    "$ n $ - liczba elementów w sortowanej tablicy (wszystkich), $ k $ - zakres unikatowych wartości (zazwyczaj liczba liczb całkowitych, jakie znajdują się w przedziale $ [0, k] $, gdzie $ k $ jest największą liczbą z sortowanej tablicy) (rzeczywiście na przedziale domkniętym jest $ k + 1 $ unikatowych wartości, ale różnica o stałą równą $ 1 $ nie jest uwzględniana w złożoności) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Każdy przypadek\n",
    "##### $ O(n + k) $\n",
    "$ k $ - tworzymy pomocniczą tablicę, w której będziemy przechowywać liczby wystąpień poszczególnych wartości pod indeksami, które odpowiadają tym wartościom (dlatego najlepiej działa ten algorytm na liczbach z małych przedziałów). Później modyfikujemy tę tablicę tak, by dla danego indeksu (odpowiadającego danej liczbie), w komórce tablicy pomocniczej o tym indeksie, występowała liczba wartości, które są nie większe niż indeks tej komórki. $ n $ - pomocnicza tablica, do której przepisujemy wartości w odpowiedniej kolejności, tak, aby je ponownie później przepisać do tablicy wyjściowej."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Stabilny\n",
    "W poniższej implementacji, gdzie przepisywanie wartości do pomocniczej tablicy rozpoczynamy od końca sortowanej tablicy. Wiele implementacji w Internecie zawiera niestabilną wersję tego algorytmu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Nie\n",
    "Zawsze musimy użyć dodatkowej pamięci, która jest zależna od danych wejściowych (tu od liczby elementów do posortowania oraz liczby unikatowych wartości z tego przedziału, do którego należą sortowane wartości)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1 (modyfikuje tablicę)\n",
    "#### (Wersja JEDYNIE dla liczb całkowitych nieujemnych od $ 0 $ do wskazanej wartości $ k $)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counting_sort(arr, k: 'the upper bound of the values range'):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * (k + 1)\n",
    "    temp = [None] * len(arr)\n",
    "    # Count values repetitions\n",
    "    for val in arr:\n",
    "        counts[val] += 1\n",
    "    # Modify the counts array to indicate how many values are not greater than the current one\n",
    "    for i in range(1, len(counts)):\n",
    "        counts[i] += counts[i-1]\n",
    "    # Rewrite values to the temp sorted array\n",
    "    for i in range(len(arr)-1, -1, -1):\n",
    "        counts[arr[i]] -= 1\n",
    "        temp[counts[arr[i]]] = arr[i]\n",
    "    # Rewrite sorted values to the initial array\n",
    "    for i in range(len(temp)):\n",
    "        arr[i] = temp[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: [56, 78, 66, 81, 38, 11, 6, 77, 94, 82, 69, 25, 52, 31, 48, 19, 19, 56, 28, 57, 39, 47, 45, 29, 22, 17, 97, 41, 44, 73, 82, 35, 29, 40, 9, 95, 74, 57, 85, 92, 59, 57, 50, 44, 88, 13, 75, 51, 23, 97, 81, 89, 87, 87, 84]\n",
      "Expected: [6, 9, 11, 13, 17, 19, 19, 22, 23, 25, 28, 29, 29, 31, 35, 38, 39, 40, 41, 44, 44, 45, 47, 48, 50, 51, 52, 56, 56, 57, 57, 57, 59, 66, 69, 73, 74, 75, 77, 78, 81, 81, 82, 82, 84, 85, 87, 87, 88, 89, 92, 94, 95, 97, 97]\n",
      "Result: [6, 9, 11, 13, 17, 19, 19, 22, 23, 25, 28, 29, 29, 31, 35, 38, 39, 40, 41, 44, 44, 45, 47, 48, 50, 51, 52, 56, 56, 57, 57, 57, 59, 66, 69, 73, 74, 75, 77, 78, 81, 81, 82, 82, 84, 85, 87, 87, 88, 89, 92, 94, 95, 97, 97]\n",
      "Correct?: True\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "max_val = 100\n",
    "val_counts = (0, 100)\n",
    "arr = [random.randint(0, max_val) for _ in range(random.randint(*val_counts))]\n",
    "print('Input:', arr)\n",
    "expected = sorted(arr)\n",
    "k = expected[-1]\n",
    "counting_sort(arr, k)\n",
    "is_correct = expected == arr\n",
    "print('Expected:', expected)\n",
    "print('Result:', arr)\n",
    "print('Correct?:', is_correct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2 (nie modyfikuje tablicy)\n",
    "#### (Wersja JEDYNIE dla liczb całkowitych nieujemnych od $ 0 $ do wskazanej wartości $ k $)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counting_sort(arr, k: 'the upper bound of the values range'):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * (k + 1)\n",
    "    new = [None] * len(arr)\n",
    "    # Count values repetitions\n",
    "    for val in arr:\n",
    "        counts[val] += 1\n",
    "    # Modify the counts array to indicate how many values are not greater than the current one\n",
    "    for i in range(1, len(counts)):\n",
    "        counts[i] += counts[i-1]\n",
    "    # Rewrite values to the temp sorted array\n",
    "    for i in range(len(arr)-1, -1, -1):\n",
    "        counts[arr[i]] -= 1\n",
    "        new[counts[arr[i]]] = arr[i]\n",
    "    return new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: [42, 30, 44, 15, 47, 2, 74, 20, 96, 57, 43, 25, 53, 25, 27, 9, 15, 89, 15, 26, 41, 43]\n",
      "Expected: [2, 9, 15, 15, 15, 20, 25, 25, 26, 27, 30, 41, 42, 43, 43, 44, 47, 53, 57, 74, 89, 96]\n",
      "Result: [2, 9, 15, 15, 15, 20, 25, 25, 26, 27, 30, 41, 42, 43, 43, 44, 47, 53, 57, 74, 89, 96]\n",
      "Correct?: True\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "max_val = 100\n",
    "val_counts = (1, 100)\n",
    "arr = [random.randint(0, max_val) for _ in range(random.randint(*val_counts))]\n",
    "expected = sorted(arr)\n",
    "k = expected[-1]\n",
    "res = counting_sort(arr, k)\n",
    "is_correct = expected == res\n",
    "print('Input:', arr)\n",
    "print('Expected:', expected)\n",
    "print('Result:', res)\n",
    "print('Correct?:', is_correct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #3 (modyfikuje tablicę - można to łatwo zmienić)\n",
    "#### (Wersja, JEDYNIE dla liczb całkowitych nieujemnych od $ 0 $ do największej wartości - której nie wskazujemy jawnie (po prostu szukamy jej liniowo, bo tablica jest nieposortowana))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counting_sort(arr):\n",
    "    if arr: _counting_sort(arr, _max_val(arr))\n",
    "        \n",
    "\n",
    "def _counting_sort(arr, k: 'the upper bound of the values range'):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * (k + 1)\n",
    "    temp = [None] * len(arr)\n",
    "    # Count values repetitions\n",
    "    for val in arr:\n",
    "        counts[val] += 1\n",
    "    # Modify the counts array to indicate how many values are not greater than the current one\n",
    "    for i in range(1, len(counts)):\n",
    "        counts[i] += counts[i-1]\n",
    "    # Rewrite values to the temp sorted array\n",
    "    for i in range(len(arr)-1, -1, -1):\n",
    "        counts[arr[i]] -= 1\n",
    "        temp[counts[arr[i]]] = arr[i]\n",
    "    # Rewrite sorted values to the initial array\n",
    "    for i in range(len(temp)):\n",
    "        arr[i] = temp[i]\n",
    "        \n",
    "        \n",
    "def _max_val(arr):\n",
    "    if not arr: return None\n",
    "    max_ = arr[0]\n",
    "    for i in range(1, len(arr)):\n",
    "        if arr[i] > max_:\n",
    "            max_ = arr[i]\n",
    "    return max_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(counting_sort, range_=(0, 100), samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #4 (modyfikuje tablicę)\n",
    "#### (Wersja, dla liczb całkowitych (MOGĄ BYĆ UJEMNE) bez konieczności wskazywania wartości najmniejszej i największej (po prostu szukamy ich liniowo w jednej pętli, bo tablica jest nieposortowana))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counting_sort(arr):\n",
    "    if arr: \n",
    "        min_, max_ = minmax(arr)\n",
    "        _counting_sort(arr, min_, max_)\n",
    "        \n",
    "\n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def _counting_sort(arr, k: 'the lower bound', m: 'the upper bound'):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * (m - k + 1)\n",
    "    temp = [None] * len(arr)\n",
    "    # Count values repetitions\n",
    "    for val in arr:\n",
    "        counts[val - k] += 1\n",
    "    # Modify the counts array to indicate how many values are not greater than the current one\n",
    "    for i in range(1, len(counts)):\n",
    "        counts[i] += counts[i-1]\n",
    "    # Rewrite values to the temp sorted array\n",
    "    for i in range(len(arr)-1, -1, -1):\n",
    "        counts[arr[i] - k] -= 1\n",
    "        temp[counts[arr[i] - k]] = arr[i]\n",
    "    # Rewrite sorted values to the initial array\n",
    "    for i in range(len(temp)):\n",
    "        arr[i] = temp[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Counting Sort (#4 - negative & positive)'] = (counting_sort, {\n",
    "    '_counting_sort': _counting_sort,\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(counting_sort, samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Radix Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Założenia, aby korzystanie z algorytmu było opłacalne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Dane wejściowe musi się dać podzielić na poszczególne fragmenty, odpowiadające pojednyczej cyfrze (lub pojedynczemu znakowi w przypadku sortowania tekstu),\n",
    "- Algorytm pomocniczy, przy pomocy którego będziemy sortować wartości według znaków (poszczególnych cyfr), musi mieć niską złożoność i, przede wszystkim, być stabilny (tylko wtedy Radix Sort działa prawidłowo)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Każdy przypadek\n",
    "##### $ O(d \\cdot (n + b)) $ <br>\n",
    "$ d = log_b(k) $, gdzie $ k $ - maksymalna wartość w sortowanej tablicy, <br>\n",
    "$ n $ - liczba elementów w sortowanej tablicy, <br>\n",
    "$ b $ - podstawa systemu liczbowego, w jakim odbywa się sortowanie (bo tyle elementów będzie miała tablica, służąca do zliczania powrótek wartości (Radix Sort zazwyczaj korzysta z Counting Sorta) (W przypadku sortowania tekstu, jako podstawę przyjmujemy różnicę między największym kodem ASCII liter a najmniejszym (plus $ 1 $), zwykle będzie to liczba $ 26 $, ponieważ tyle jest małych liter alfabetu łacińskiego. Samo sortowanie wygląda jednak nieco inaczej niż w przypadku sortowania liczb, co zostało zaprezentowane w jednej z poniższych implementacji)\n",
    "###### UWAGA\n",
    "Najlepszą złożoność obliczeniową uzyskamy wtedy, gdy $ b \\approx n $, ponieważ wówczas $ d \\approx log_n(k) $ ma niewielką wartość i równocześnie suma $ n + b \\approx 2 \\cdot n $, a więc $ 2 $-krotne zwiększenie czynnika $ (n + b) $ spowodowało nam znacznie zmniejszenie czynnika $ d $. Nie możemy jednak wziąć dowolnie dużej wartości $ b $, ponieważ wpłynie to negatywnie na złożoność pamięciową, która wynosi $ O(n + b) $, a także obliczeniową, która wtedy, mimo iż $ d \\rightarrow 0 $, będzie wysoka, ponieważ będziemy musieli zaalokować $ O(n + b) $ pamięci, a alokacja odbywa się w czasie proporcjonalnym do alokowanego miejsca, czyli w tym przypadku będzie to $ O(n + b) $. <br>\n",
    "Przy założeniu, że $ b = \\theta(n) $, otrzymujemy złożoność: <br>\n",
    "$ O(d \\cdot (n + n)) = O(d \\cdot n) $ <br>\n",
    "Jeżeli również mamy stałe górne ograniczenie na wielkość liczb (tzn. $ k $ nie przekracza pewnej ustalonej wartości), z dobrym przybliżeniem można przyjąć, że $ O(d) = O(log_b(k)) = | b = \\theta(n) | = O(log_n(k)) \\approx O(1) $ (w notacji dużego $ O $ i tak zawsze $ k = O(1) $, jeżeli $ k $ - ustalone, ale tu dodatkowo bierzemy logarytm o podstawie $ n $ z liczby $ k $, więc tym bardziej wartość $ d = log_n(k) $ jest bliska jedynce). Otrzymujemy wówczas: <br>\n",
    "$ O(d \\cdot n) = | d = log_n(k), k = const. \\Rightarrow d = O(1) | = O(n) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Każdy przypadek\n",
    "##### $ O(n + b) $\n",
    "$ n $ - liczba sortowanych elementów (tyle elementów będzie miała tablica temp), <br>\n",
    "$ b $ - podstawa systemu liczbowego (tyle elementów będzie miała tablica count). Podstawa ta może być dowolna (nie musimy koniecznie sortować liczb dziesiętnych, biorąc za podstawę systemu liczbowego wartość $ b = 10 $).\n",
    "###### UWAGA\n",
    "Dla $ b = \\theta(n) $, otrzymujemy: <br>\n",
    "$ O(n + n) = O(n) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Stabilny\n",
    "Jest to jedna z cech tego algorytmu, że żeby działał on prawidłowo, do sortowania wybieramy jako algorytm pomocniczy algorytm stabilny, np. Counting Sort."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Nie\n",
    "Zawsze musimy użyć dodatkowej pamięci, która jest zależna od danych wejściowych (tu od liczby elementów do posortowania oraz liczby unikatowych wartości z tego przedziału, do którego należą sortowane wartości)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1 (z pomocą Counting Sorta)\n",
    "#### (Wersja JEDYNIE dla liczb całkowitych nieujemnych)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def radix_sort(arr, base=None):\n",
    "    n = len(arr)\n",
    "    if n > 1:\n",
    "        if base is None: base = n\n",
    "        # Store the greatest value\n",
    "        max_val = _max(arr)\n",
    "        \n",
    "        digit_place = 1\n",
    "        while max_val >= digit_place:\n",
    "            _counting_sort(arr, base, digit_place)\n",
    "            digit_place *= base\n",
    "\n",
    "\n",
    "def _counting_sort(arr, base, digit_place):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * base\n",
    "    temp = [None] * len(arr)\n",
    "    # Count digits repetitions\n",
    "    for val in arr:\n",
    "        digit = (val // digit_place) % base\n",
    "        counts[digit] += 1\n",
    "    # Modify the counts array to indicate how many digits are not greater than the current one\n",
    "    for i in range(1, base):\n",
    "        counts[i] += counts[i-1]\n",
    "    # Rewrite values to the temp sorted array\n",
    "    for i in range(len(arr)-1, -1, -1):\n",
    "        digit = (arr[i] // digit_place) % base\n",
    "        counts[digit] -= 1\n",
    "        temp[counts[digit]] = arr[i]\n",
    "    # Rewrite sorted values to the initial array\n",
    "    for i in range(len(temp)):\n",
    "        arr[i] = temp[i]\n",
    "        \n",
    "        \n",
    "def _max(arr):\n",
    "    if arr:\n",
    "        max_val = arr[0]\n",
    "        for i in range(1, len(arr)):\n",
    "            if arr[i] > max_val:\n",
    "                max_val = arr[i]\n",
    "        return max_val\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(radix_sort, range_=(0, 100), samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2 (z pomocą Counting Sorta)\n",
    "#### (Wersja dla WSZYSTKICH liczb całkowitych)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def radix_sort(arr, base=None):\n",
    "    n = len(arr)\n",
    "    if n > 1:\n",
    "        if base is None: base = n\n",
    "        first_non_negative_idx, min_negative, max_positive = _partition(arr)\n",
    "        # If not all the numbers are positive (there are some negative integers)\n",
    "        if first_non_negative_idx > 0:\n",
    "            _radix_sort(arr, 0, first_non_negative_idx - 1, min_negative, base)\n",
    "        # If not all the numbers are negative (there are some positive integers)\n",
    "        if first_non_negative_idx < len(arr):\n",
    "            _radix_sort(arr, first_non_negative_idx, len(arr) - 1, max_positive, base)\n",
    "            \n",
    "            \n",
    "def _radix_sort(arr, begin_idx, end_idx, limit, base):\n",
    "    digit_place = 1\n",
    "    limit = abs(limit)\n",
    "    while limit >= digit_place:\n",
    "        _counting_sort(arr, begin_idx, end_idx, digit_place, base)\n",
    "        digit_place *= base\n",
    "            \n",
    "# This function moves negative elements to the left and positive ones to the right side\n",
    "# of an array. Time complexity is only O(n) as it uses approach similar to the Quick Sort\n",
    "# Lomuto's partition with the pivot set to -1 as it partitions an array into a part of values \n",
    "# lower than or equal to a pivot and values greater than a pivot\n",
    "def _partition(arr):\n",
    "    pivot = -1\n",
    "    max_val = arr[0]\n",
    "    # If there is no negative number, we will still return -1 value (this value is used only\n",
    "    # to store the lowest number (if there are negative numbers))\n",
    "    min_val = -1\n",
    "\n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater than a pivot\n",
    "    i = 0\n",
    "    for j in range(len(arr)):\n",
    "        if arr[j] <= pivot:\n",
    "            if arr[j] < min_val:\n",
    "                min_val = arr[j]\n",
    "            _swap(arr, i, j)\n",
    "            i += 1\n",
    "        elif arr[j] > max_val:\n",
    "            max_val = arr[j]\n",
    "\n",
    "    return i, min_val, max_val\n",
    "\n",
    "        \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]\n",
    "\n",
    "\n",
    "def _counting_sort(arr, begin_idx, end_idx, digit_place, base):\n",
    "    # Allocate memory for required temporary arrays\n",
    "    counts = [0] * base\n",
    "    result = [None] * (end_idx - begin_idx + 1)\n",
    "    # Count digits repetitions\n",
    "    for i in range(begin_idx, end_idx + 1):\n",
    "        digit = (arr[i] // digit_place) % base\n",
    "        counts[digit] += 1\n",
    "    # Modify the counts array to indicate how many digits are not greater than the current one\n",
    "    for i in range(1, base):\n",
    "        counts[i] += counts[i - 1]\n",
    "    # Rewrite values to the result sorted array\n",
    "    for i in range(end_idx, begin_idx - 1, -1):\n",
    "        digit = (arr[i] // digit_place) % base\n",
    "        counts[digit] -= 1\n",
    "        result[counts[digit]] = arr[i]\n",
    "    # Rewrite sorted values to the initial array\n",
    "    for i in range(len(result)):\n",
    "        arr[begin_idx + i] = result[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Radix Sort (#2 - negative & positive)'] = (radix_sort, {\n",
    "    '_counting_sort': _counting_sort,\n",
    "    '_radix_sort': _radix_sort,\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(radix_sort, samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucket Sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Założenia, aby korzystanie z algorytmu było opłacalne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- MAMY PEWNOŚĆ, że otrzymujemy dane wejściowe o ROZKŁADZIE JEDNOSTAJNYM. Oznacza to, że każde z wiaderek, na które podzielimy dane wejściowe (w czasie liniowym), będzie zawierało zbliżoną liczbę elementów do pozostałych wiaderek,\n",
    "- Tak naprawdę algorytm sortowania Bucket Sort sam w sobie nie jest algorytmem sortowania, a jedynie algorytmem, który dzieli dane wejściowe na mniejsze, szybsze i łatwiejsze w sortowaniu zbiory danych,\n",
    "- Podzielone na wiaderka dane musimy posortować jakimś wydajnym (w zależności od liczby elementów w wiaderku) algorytmem. Jeżeli liczba elementów jest niewielka, najlepiej się sprawdzi uniwersalny algorytm sortowania, jakim jest Insertion Sort (dla małych danych algorytm ten jest szybki, poza tym, jest to stabilny algorytm sortowania, więc możemy otrzymać stabilną wersję Bucket Sorta i jeszcze jedno, dla prawie posortowanych danych, złożoność Insertion Sorta jest liniowa, a więc istnieje największa szansa, że użycie tego prostego algorytmu o średniej złożoności obliczeniowej $ O(n^2) $, spowoduje posortowanie niektórych wiaderek w czasie liniowym), natomiast dla większych wiaderek, lepiej wykorzystać jakiś algorytm o złożoności $ O(n \\cdot log(n)) $,\n",
    "- Warto dodać, że jeżeli pojemniki (wiaderka) zawierają liczby całkowite lub ciągi tekstowe, można wykorzystać np. Radix Sorta do posortowania każdego z pojemników lub Counting Sorta, jeżeli zakres liczb jest niewielki, a liczb o powtarzającej się wartości jest dużo,\n",
    "- Ponieważ nie mamy pewności, ile dokładnie elementów trafi do danego pojemnika, nie opłaca się alokować pamięci \"na sztywno\" dla każdego z pojemników. Lepiej wykorzystać listę odsyłaczową (patrz plik z sortowaniem list odsyłaczowych) lub dynamiczną tablicę (np. Pythonową listę - my ją wykorzystamy w poniższych przykładach)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Złożoność sortowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność czasowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najlepszy przypadek\n",
    "##### $ O(n + k) $\n",
    "$ O(n) $ - czas utworzenia kubełków (jest on równy $ O(n) $, ponieważ zawsze liczba kubełków powinna zależeć od wielkości danych wejściowych oraz konieczne jest liniowe przejście po tablicy i umieszczenie wartości w odpowiednich wiaderkach)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ O(k) $ - czas sortowania wszystkich kubełków (zależny od liczby kubełków) (przyjmujemy, że czas sortowania pojedynczego kubełka jest w przybliżeniu stały, ponieważ zawiera on niewielką liczbę elementów; dokładniej, to skoro $ k ~ n $, to iloraz $ \\frac{n}{k} $, który wynosi tyle, ile przybliżona liczba elementów, które przypadają na jeden kubełek, jest stały (zwykle ustalamy tę liczbę odgórnie, zamiast liczby kubełków))\n",
    "###### UWAGA:\n",
    "Aby osiągnąć złożoność liniową, musimy ustalić tak wartość $ k $, aby zależała ona od $ n $.\n",
    "<br><br>\n",
    "W powyższych oszacowaniach przyjąłem następujące oznaczenia: <br>\n",
    "$ k $ - liczba kubełków, <br>\n",
    "$ n $ - liczba elementów w sortowanej tablicy, <br>\n",
    "<br>\n",
    "W implementacjach algorytmu, jakie zamieściłem niżej, $ k $ oznacza stosunek liczby elementów w tablicy ($ n $) do liczby kubełków, jakie mają zostać utworzone, czyli średnią liczbę elementów, które przypadają na pojedynczy kubełek."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Najgorszy przypadek\n",
    "##### $ O(n^2) $\n",
    "W praktyce, przy dobrym doborze wiaderek, istnieje niewielka szansa na osiągnięcie złożoności $ O(n^2) $. Złożoność będzie tym bliższa złożoności pesymistycznej ($ O(n^2) $), im więcej wartości trafi do pojedynczego wiaderka (w szczególności, gdy wszystkie wartości znajdą się w jednym wiaderku, a wiaderka sortujemy algorytmem o złożoności $ O(n^2) $)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Złożoność pamięciowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Każdy przypadek\n",
    "##### $ O(n + k) $\n",
    "Zależy od liczby elementów, jakie otrzymujemy w tablicy do posortowania oraz od liczby kubełków, jakie tworzymy. Ponieważ powinniśmy dobrać tak liczbę kubełków $ k $, aby $ k = \\theta(n) $ (asymptotycznie $ k $ musi być liniowe względem rozmiaru tablicy do posortowania), otrzymamy złożoność pamięciową $ O(n + n) = O(n) $."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stabilność"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Zależy\n",
    "Stabilność jest zależna od algorytmu użytego do sortowania wiaderek. Sam Bucket Sort nie przeprowadza sortowania, więc jego stabilność jest uzależniona od stabilności algorytmu, który odpowiada za posortowanie każdego z wiaderek. Jeżeli korzystamy z Insertion Sorta, algorytm Bucket Sort jest stabilny."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Czy sortowanie odbywa się w miejscu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Nie\n",
    "Zawsze musimy użyć dodatkowej pamięci, która jest zależna od danych wejściowych (tu od liczby elementów do posortowania oraz liczby wiaderek, która również zależy od wielkości danych wejściowych)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #1 (z pomocą Insertion Sorta)\n",
    "#### (Wersja dla dowolnych liczb rzeczywistych)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdecydowałem się na wybór Insertion Sorta do posortowania wiaderek, ponieważ jest on stabilnym algorytmem sortowania oraz dla małych danych (do ok. 24 elementów - patrz porównanie wydajności dla takich danych na końcu pliku) jest bardzo szybki. W poniższej implementacji wykorzystuję liczbę wiaderek, która jest równa $ \\frac{1}{16} $ wielkości danych ($ \\frac{2}{3} \\cdot 24 = 16 $) wejściowych tak, aby każde z wiaderek miało odpowiednio niewielką liczbę elementów, dzięki czemu da się je szybko posortować. Oczywiście można użyć innej wartości tego współczynnika, ale, uwzględniając możliwe odchylenia w obie strony od liczby 16, chcę, aby w jak największej liczbie wiaderek, liczba elementów nie przekroczyła zbyt mocno liczby 24."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bucket_sort(arr, k: 'threshold' = 24):\n",
    "    if len(arr) <= k:\n",
    "        insertion_sort(arr)\n",
    "    else:\n",
    "        # Create buckets\n",
    "        m = int(2/3 * k)\n",
    "        buckets_count = len(arr) // m + 1\n",
    "        buckets = [[] for _ in range(buckets_count)]\n",
    "        min_val, max_val = minmax(arr)\n",
    "        val_interval = (max_val - min_val) / buckets_count\n",
    "        # Distribute values to the proper buckets\n",
    "        for val in arr:\n",
    "            # Calculate the bucket's index depending on how much the \n",
    "            # current value is greater than the lowest one\n",
    "            bucket_idx = int((val - min_val) / val_interval - .5)  # Round down in order not to overflow an array\n",
    "            buckets[bucket_idx].append(val)\n",
    "        # Sort each bucket separately\n",
    "        for bucket in buckets:\n",
    "            insertion_sort(bucket)\n",
    "        # Rewrite sorted values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#1 - with Insertion Sort)'] = (bucket_sort, {\n",
    "    'insertion_sort': insertion_sort,\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(bucket_sort, range_=(-1000, 10000), val_counts=(0, 10_000), samples=1000, failed_only=True)\n",
    "# test_sort(bucket_sort, range_=(-1000, 1000), val_counts=(0, 10_000), samples=1000, ints_only=False, failed_only=True)\n",
    "test_sort(bucket_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #2 (z pomocą Counting Sorta)\n",
    "#### (Wersja dla liczb CAŁKOWITYCH NIEUJEMNYCH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta implementacja tak w rzeczywistości jest alternatywą dla zwykłego Counting Sorta, ponieważ zamiast komórek, które wskazują na liczbę wartości niewiększych niż wartość równa indeksowi danej kolumny, stosujemy wiaderka, w których od razu umieszczamy liczby (nie inkrementujemy licznika). Ta implementacja używa list Pythonowych. Implementacja na listach odsyłaczowych znajduje się w pliku z algorytmami sortowania list odsyłaczowych. (Oczywiście ten, jak i poniższy algorytm sortowania, jest niewydajny pamięciowo, jeżeli sortowana jest tablica bardzo różniących się między sobą wartości)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bucket_counting_sort(arr):\n",
    "    if len(arr) > 1:\n",
    "        max_val = _max(arr)\n",
    "        # Allocate memory for values (our buckets)\n",
    "        buckets = [[] for _ in range(max_val + 1)]\n",
    "        # Store values in the proper buckets\n",
    "        for val in arr:\n",
    "            buckets[val].append(val)\n",
    "        # Rewrite all values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def _max(arr):\n",
    "    if not arr: return None\n",
    "    max_val = arr[0]\n",
    "    for i in range(1, len(arr)):\n",
    "        if arr[i] > max_val:\n",
    "            max_val = arr[i]\n",
    "    return max_val     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(bucket_counting_sort, range_=(0, 100), samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #3 (z pomocą Counting Sorta)\n",
    "#### (Wersja dla WSZYSTKICH liczb CAŁKOWITYCH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta implementacja tak w rzeczywistości jest alternatywą dla zwykłego Counting Sorta w wersji dla wszystkich liczb całkowitych. Działa analogicznie jak wyżej. Tak naprawdę ten algorytm nie wymaga żadnego sortowania ani zliczania wartości, a jedynie ich włożenie do odpwiednich wiaderek, a następnie ich połączenie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bucket_counting_sort(arr):\n",
    "    if len(arr) > 1:\n",
    "        min_val, max_val = minmax(arr)\n",
    "        # Allocate memory for values (our buckets)\n",
    "        buckets = [[] for _ in range(max_val - min_val + 1)]\n",
    "        # Store values in the proper buckets\n",
    "        for val in arr:\n",
    "            buckets[val - min_val].append(val)\n",
    "        # Rewrite all values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#3 - Counting Sort variation)'] = (bucket_counting_sort, {\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "test_sort(bucket_counting_sort, samples=100, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #4 (z pomocą Bucket Sorta oraz Insertion Sorta)\n",
    "#### (Wersja dla dowolnych liczb rzeczywistych)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jest to ulepszona wersja Bucket Sorta, która sortuje wiaderka, przy pomocy Bucket Sorta, jeżeli w danym wiaderku znajduje się duża liczba elementów. W poniższej implementacji uznałem, że jeżeli zawartość wiaderka przekracza liczbę równą 24, należy dane wiaderko przesortować również Bucket Sortem. W rzeczywistości przy danych wejściowych o rozkładzie jednostajnym nie zauważymy żadnego wzrostu wydajności. Pewne przyspieszenie działania algorytmu zaobserwujemy w przypadku danych, które nie przypominają rozkładu normalnego."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use k as a threshold which indicates when to start using Insertion Sort\n",
    "def bucket_sort(arr, *, k: 'threshold' = 24):\n",
    "    # If a bucket is small enough, use an Insertion Sort algorithm to\n",
    "    # sort this bucket\n",
    "    if len(arr) <= k:\n",
    "        insertion_sort(arr)\n",
    "    else:\n",
    "        _bucket_sort(arr, k)\n",
    "        \n",
    "        \n",
    "def _bucket_sort(arr, k):\n",
    "    # Store the maximum and the minimum value of a bucket\n",
    "    min_val, max_val = minmax(arr)\n",
    "    # Sort a bucket if only there is more than one unique value\n",
    "    if min_val != max_val:\n",
    "        # Make a threshold a bit smaller as a number of elements in each\n",
    "        # bucket can slightly vary and we don't want to make unnecessary\n",
    "        # recursive calls.\n",
    "        m = int(2/3 * k)\n",
    "        # Create buckets\n",
    "        buckets_count = len(arr) // m + 1\n",
    "        buckets = [[] for _ in range(buckets_count)]\n",
    "        val_interval = (max_val - min_val) / buckets_count\n",
    "        # Distribute values to the proper buckets\n",
    "        for val in arr:\n",
    "            # Calculate the bucket's index depending on how much the \n",
    "            # current value is greater than the lowest one\n",
    "            bucket_idx = int((val - min_val) / val_interval - .5)\n",
    "            buckets[bucket_idx].append(val)\n",
    "        # Sort each bucket separately\n",
    "        for bucket in buckets:\n",
    "            # Bucket sort all of the buckets again\n",
    "            bucket_sort(bucket, k=k)\n",
    "        # Rewrite sorted values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#4 - recursive with Bucket Sort)'] = (bucket_sort, {\n",
    "    'bucket_sort': bucket_sort,\n",
    "    '_bucket_sort': _bucket_sort,\n",
    "    'insertion_sort': insertion_sort,\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(bucket_sort, samples=100, ints_only=False, uniform_distribution=False)\n",
    "test_sort(bucket_sort, samples=100, range_=(-1000, 1000), \n",
    "          val_counts=(0, 10_000), ints_only=False, uniform_distribution=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #5 (z pomocą Bucket Sorta oraz Insertion Sorta)\n",
    "#### (Wersja iteracyjna z użyciem stosu dla dowolnych liczb rzeczywistych)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak wyżej, ale nie występuje problem z możliwym przepełnieniem stosu rekurencyjnego dla bardzo dużych danych wejściowych (W rzeczywistości sytuacja taka jest prawie niemożliwa w rekurencyjnej wersji Bucket Sorta przedstawionej wyżej, ponieważ zawsze dzielimy wiaderka na odpowiednią liczbę mniejszych wiaderek, która jest wyznaczana odpowiednio dla zakresu wartości w wiaderku)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use k as a threshold which indicates when to start using Insertion Sort\n",
    "def bucket_sort(arr, *, k: 'threshold' = 24):\n",
    "    buckets_stack = [arr]\n",
    "    idx = len(arr) - 1\n",
    "    while buckets_stack:\n",
    "        # Get the last bucket from a stack\n",
    "        bucket = buckets_stack.pop()\n",
    "        # If it is small enough, sort it and rewrite values to the initial array\n",
    "        if len(bucket) < k:\n",
    "            insertion_sort(bucket)\n",
    "            # Rewrite sorted values from buckets to the initial array\n",
    "            idx = _rewrite_bucket(arr, idx, bucket)\n",
    "        # Split a bucket into smaller buckets otherwise\n",
    "        else:\n",
    "            min_val, max_val = minmax(bucket)\n",
    "            # If a bucket consists of all the same values\n",
    "            if max_val == min_val:\n",
    "                # Rewrite sorted values from buckets to the initial array\n",
    "                idx = _rewrite_bucket(arr, idx, bucket)\n",
    "            else:\n",
    "                # Add buckets to the stack in order to sort them later\n",
    "                for bucket in _divide_into_buckets(bucket, min_val, max_val, k):\n",
    "                    if bucket:\n",
    "                        buckets_stack.append(bucket)\n",
    "        \n",
    "        \n",
    "def _rewrite_bucket(arr, idx, bucket):\n",
    "    for i in range(len(bucket)-1, -1, -1):\n",
    "        arr[idx] = bucket[i]\n",
    "        idx -= 1\n",
    "    return idx\n",
    "\n",
    "\n",
    "def _divide_into_buckets(bucket, min_val, max_val, k):\n",
    "    m = int(2/3 * k)\n",
    "    buckets_count = len(bucket) // m + 1\n",
    "    buckets = [[] for _ in range(buckets_count)]    \n",
    "    val_interval = (max_val - min_val) / buckets_count\n",
    "    # Distribute values to the proper buckets\n",
    "    for val in bucket:\n",
    "        # Calculate the bucket's index depending on how much the \n",
    "        # current value is greater than the lowest one\n",
    "        bucket_idx = int((val - min_val) / val_interval - .5)\n",
    "        buckets[bucket_idx].append(val)\n",
    "    return buckets\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#5 - iterative with Bucket Sort)'] = (bucket_sort, {\n",
    "    'insertion_sort': insertion_sort,\n",
    "    'minmax': minmax,\n",
    "    '_rewrite_bucket': _rewrite_bucket,\n",
    "    '_divide_into_buckets': _divide_into_buckets\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100000/100000\n"
     ]
    }
   ],
   "source": [
    "test_sort(bucket_sort, samples=100_000, ints_only=False, uniform_distribution=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #6 (z pomocą Quick Sorta oraz Insertion Sorta)\n",
    "#### (Algorytm combo, który najpierw dzieli liczby na wiaderka, a następnie duże wiaderka sortuje Quick Sortem, a małe Insertion Sortem)\n",
    "(Takie podejście pozwala nam zniwelować ryzyko utworzenia ogromnej liczby zbędnych wiaderek, jak to było możliwe w przypadku Bucket Sorta, który korzystał z Bucket Sorta dla dużych wiaderek i jednocześnie zachować najlepszą złożoność czasową równą $ O(n) $ - w przypadku rozkładu jednostajnego oraz $ O(n \\cdot log(n)) $ - w najgorszym przypadku (zazwyczaj i tak część wiaderek zostanie posortowana Insertion Sortem w czasie stałym, bo mają one określoną, niezależną od $ n $ wielkość))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combo_sort(arr, *, k: 'threshold' = 24):\n",
    "    if len(arr) <= k:\n",
    "        insertion_sort(arr)\n",
    "    else:\n",
    "        # Create buckets\n",
    "        m = int(2/3 * k)\n",
    "        buckets_count = len(arr) // m + 1\n",
    "        buckets = [[] for _ in range(buckets_count)]\n",
    "        min_val, max_val = minmax(arr)\n",
    "        val_interval = (max_val - min_val) / buckets_count\n",
    "        # Distribute values to the proper buckets\n",
    "        for val in arr:\n",
    "            # Calculate the bucket's index depending on how much the \n",
    "            # current value is greater than the lowest one\n",
    "            bucket_idx = int((val - min_val) / val_interval - .5)  # Round down in order not to overflow an array\n",
    "            buckets[bucket_idx].append(val)\n",
    "        # Sort each bucket separately\n",
    "        for bucket in buckets:\n",
    "            if len(bucket) < k:\n",
    "                insertion_sort(bucket)\n",
    "            else:\n",
    "                quick_sort(bucket)\n",
    "        # Rewrite sorted values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp\n",
    "\n",
    "\n",
    "def quick_sort(arr):\n",
    "    _quick_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quick_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        pivot_position = _partition(arr, left_idx, right_idx)\n",
    "        \n",
    "        if pivot_position - left_idx < right_idx - pivot_position:\n",
    "            _quick_sort(arr, left_idx, pivot_position)\n",
    "            left_idx = pivot_position + 1  # I removed a tailing recursion\n",
    "        else:\n",
    "            _quick_sort(arr, pivot_position + 1, right_idx)\n",
    "            right_idx = pivot_position  # I removed a tailing recursion\n",
    "        \n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[left_idx]\n",
    "    \n",
    "    # Partition an array into 2 subarrays of elements lower than or\n",
    "    # equal to a pivot and of elements greater or equal to a pivot \n",
    "    # (in this partition algorithm pivot isn't placed on a fixed position \n",
    "    # but can be also swapped like all the remaining values)\n",
    "    i = left_idx - 1\n",
    "    j = right_idx + 1\n",
    "    while True:\n",
    "        i += 1\n",
    "        while arr[i] < pivot: i += 1\n",
    "            \n",
    "        j -= 1\n",
    "        while arr[j] > pivot: j -= 1\n",
    "        \n",
    "        if i < j:\n",
    "            _swap(arr, i, j)\n",
    "        else:\n",
    "            return j  # Return a pivot position after the last swap\n",
    "\n",
    "    \n",
    "def _swap(arr, i, j):\n",
    "    arr[i], arr[j] = arr[j], arr[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#6 - Quick Sort & Insertion Sort)'] = (combo_sort, {\n",
    "    'insertion_sort': insertion_sort,\n",
    "    'quick_sort': quick_sort,\n",
    "    '_quick_sort': _quick_sort,\n",
    "    '_partition': _partition,\n",
    "    '_swap': _swap,\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(combo_sort, samples=10000, range_=(-10_000, 10_000), val_counts=(0, 10_000), \n",
    "#           ints_only=False, failed_only=True, uniform_distribution=False)\n",
    "test_sort(combo_sort, samples=100, ints_only=False, uniform_distribution=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu #7 (z pomocą Quicker Sorta oraz Insertion Sorta)\n",
    "#### (Algorytm combo, który najpierw dzieli liczby na wiaderka, a następnie duże wiaderka sortuje Quicker Sortem, a małe Insertion Sortem)\n",
    "(Podobnie jak wyżej, ale powinien działać szybciej, jeżeli dużo identycznych liczb trafi do tego samego wiaderka (Zazwyczaj wzrost wydajności widać od razu dla liczb całkowitych. W przypadku liczb rzeczywistych jest mniejsze prawdopodobieństwo wystąpienia kilku takich samych wartości))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combo_sort(arr, *, k: 'threshold' = 24):\n",
    "    if len(arr) <= k:\n",
    "        insertion_sort(arr)\n",
    "    else:\n",
    "        # Create buckets\n",
    "        m = int(2/3 * k)\n",
    "        buckets_count = len(arr) // m + 1\n",
    "        buckets = [[] for _ in range(buckets_count)]\n",
    "        min_val, max_val = minmax(arr)\n",
    "        val_interval = (max_val - min_val) / buckets_count\n",
    "        # Distribute values to the proper buckets\n",
    "        for val in arr:\n",
    "            # Calculate the bucket's index depending on how much the \n",
    "            # current value is greater than the lowest one\n",
    "            bucket_idx = int((val - min_val) / val_interval - .5)  # Round down in order not to overflow an array\n",
    "            buckets[bucket_idx].append(val)\n",
    "        # Sort each bucket separately\n",
    "        for bucket in buckets:\n",
    "            if len(bucket) < k:\n",
    "                insertion_sort(bucket)\n",
    "            else:\n",
    "                quicker_sort(bucket)\n",
    "        # Rewrite sorted values from buckets to the initial array\n",
    "        i = 0\n",
    "        for bucket in buckets:\n",
    "            for val in bucket:\n",
    "                arr[i] = val\n",
    "                i += 1\n",
    "        \n",
    "        \n",
    "def minmax(arr):\n",
    "    global_min = global_max = arr[-1]\n",
    "    \n",
    "    for i in range(0, len(arr)-1, 2):\n",
    "        if arr[i] > arr[i+1]:\n",
    "            if arr[i] > global_max:   global_max = arr[i]\n",
    "            if arr[i+1] < global_min: global_min = arr[i+1]\n",
    "        else:\n",
    "            if arr[i+1] > global_max: global_max = arr[i+1]\n",
    "            if arr[i] < global_min:   global_min = arr[i]\n",
    "    return global_min, global_max\n",
    "\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        j = i-1\n",
    "        temp = arr[i]\n",
    "        \n",
    "        while j >= 0 and temp < arr[j]:\n",
    "            arr[j+1] = arr[j]\n",
    "            j -= 1\n",
    "        \n",
    "        arr[j+1] = temp\n",
    "\n",
    "\n",
    "def quicker_sort(arr):\n",
    "    _quicker_sort(arr, 0, len(arr) - 1)\n",
    "    \n",
    "\n",
    "def _quicker_sort(arr, left_idx, right_idx):\n",
    "    while left_idx < right_idx:\n",
    "        lt_pivot_last, gt_pivot_first = _partition(arr, left_idx, right_idx)\n",
    "        \n",
    "        # If a number of elements lower tha a pivot is greater than a number\n",
    "        # of elements greater than a pivot, sort recursively the shorter part\n",
    "        # of elements which are greater than a pivot\n",
    "        if lt_pivot_last - left_idx > right_idx - gt_pivot_first:\n",
    "            _quicker_sort(arr, gt_pivot_first, right_idx)\n",
    "            right_idx = lt_pivot_last  # I removed a tailing recursion\n",
    "        # Otherwise, sort a subarray of elementslower than a pivot first\n",
    "        # as it is shorter than a subarray of elements greater than a pivot\n",
    "        else:\n",
    "            _quicker_sort(arr, left_idx, lt_pivot_last)\n",
    "            left_idx = gt_pivot_first  # I removed a tailing recursion\n",
    "\n",
    "        \n",
    "def _partition(arr, left_idx, right_idx):\n",
    "    pivot = arr[left_idx]\n",
    "    \n",
    "    # Partition an array into 3 subarrays (lower than, equal to and\n",
    "    # greater than a pivot value)\n",
    "    i = left_idx     # A pointer of the first pivot\n",
    "    j = left_idx + 1 # A pointer of the element after the last pivot\n",
    "    k = j            # A pointer of the currently checked element \n",
    "    while k <= right_idx:\n",
    "        if arr[k] < pivot:\n",
    "            _two_swaps(arr, i, j, k)\n",
    "            i += 1\n",
    "            j += 1\n",
    "        elif arr[k] == pivot:\n",
    "            _one_swap(arr, j, k)\n",
    "            j += 1\n",
    "        k += 1\n",
    "        \n",
    "    # Return the last index of the subarray of elements lower than a pivot\n",
    "    # and the first index of the subarray of elements greater than a pivot\n",
    "    return i - 1, j\n",
    "\n",
    "    \n",
    "def _one_swap(arr, i, j):\n",
    "    # Swap two elements in an array\n",
    "    arr[i], arr[j] = arr[j], arr[i]\n",
    "    \n",
    "\n",
    "def _two_swaps(arr, i, j, k):\n",
    "    # Rotate right the elements of the indices specified\n",
    "    arr[k], arr[j], arr[i] = arr[j], arr[i], arr[k]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Zapisujemy funkcję do późniejszego benchmarku (nie jest to częścią algorytmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Bucket Sort (#7 - Quicker Sort & Insertion Sort)'] = (combo_sort, {\n",
    "    'insertion_sort': insertion_sort,\n",
    "    'quicker_sort': quicker_sort,\n",
    "    '_quicker_sort': _quicker_sort,\n",
    "    '_partition': _partition,\n",
    "    '_one_swap': _one_swap,\n",
    "    '_two_swaps': _two_swaps,\n",
    "    'minmax': minmax\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kilka testów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorting algorithm is correct\n",
      "Passed tests in total: 100/100\n"
     ]
    }
   ],
   "source": [
    "# test_sort(combo_sort, samples=10000, range_=(-10_000, 10_000), val_counts=(0, 10_000), \n",
    "#           ints_only=True, failed_only=True, uniform_distribution=False)\n",
    "test_sort(combo_sort, samples=100, ints_only=False, failed_only=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Porównanie szybkości"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dodamy jeszcze dla porównania wbudowaną w Pythona funkcję sortującą \n",
    "(ponieważ nie możemy dodać metody .sort(), bo funkcja porównująca szybkość sortowań akceptuje tylko funkcje jako argument, użyjemy funkcji sorted, która zwraca posortowaną tablicę, zamiast sortować ją w miejscu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak łatwo będzie można zauważyć, wbudowana w Python funkcja sortująca bije na głowę każdy inny algorytm, jaki napisaliśmy. Nie wynika to z faktu, że nasze algorytmy są złe, ale z tego, że Python jest napisany w języku kompilowanym C (przynajmniej jego najbardziej popularna odmiana, czyli tzw. CPython, z którego korzystam), a więc wszystkie wbudowane w niego elementy są dużo szybsze od tych, które możemy sami napisać. Jeżeli piszemy algorytm sortujący, Python, jako, że jest językiem interpretowanym, musi interpretować na bieżąco nasz kod, na co schodzi dużo czasu. Jeżeli użyjemy gotowych rozwiązań, które są dostarczane wraz z językiem, Python nie musi interpretować kodu, sprawdzać składni funkcji sortującej, badać wyjątków, bo jest ona przetestowana i skompilowana, a więc przetłumaczona na kod maszynowy, który nie musi być na bieżąco interpretowany i tłumaczony, jak ma to miejsce w przypadku naszych programów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorting_functions['Sorted (Python\\'s built-in)'] = (sorted, {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0] Bubble Sort\n",
      "[1] Selection Sort\n",
      "[2] Insertion Sort\n",
      "[3] Merge Sort (#1)\n",
      "[4] Merge Sort (#2)\n",
      "[5] Merge Sort (#3)\n",
      "[6] Heap Sort (#1)\n",
      "[7] Heap Sort (#2)\n",
      "[8] Quick Sort (#1 - Lomuto parition)\n",
      "[9] Quick Sort (#2 - Hoare's partition)\n",
      "[10] Quick Sort (#3 - random pivot)\n",
      "[11] Quick Sort (#4 - O(log n) memory)\n",
      "[12] Quick Sort (#5 - static stack)\n",
      "[13] Quick Sort (#6 - dynamic stack)\n",
      "[14] Quick Sort (#7 - median of medians pivot)\n",
      "[15] Quick Sort (#8 - own sorting function)\n",
      "[16] Quicker Sort (#1 - recursive)\n",
      "[17] Quicker Sort (#2 - median of medians pivot)\n",
      "[18] Counting Sort (#4 - negative & positive)\n",
      "[19] Radix Sort (#2 - negative & positive)\n",
      "[20] Bucket Sort (#1 - with Insertion Sort)\n",
      "[21] Bucket Sort (#3 - Counting Sort variation)\n",
      "[22] Bucket Sort (#4 - recursive with Bucket Sort)\n",
      "[23] Bucket Sort (#5 - iterative with Bucket Sort)\n",
      "[24] Bucket Sort (#6 - Quick Sort & Insertion Sort)\n",
      "[25] Bucket Sort (#7 - Quicker Sort & Insertion Sort)\n",
      "[26] Sorted (Python's built-in)\n"
     ]
    }
   ],
   "source": [
    "for i, (name, value) in enumerate(sorting_functions.items()):\n",
    "    print(f'[{i}] {name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose(*numbers):  # If no number is specified, all functions will be compared\n",
    "    result = []\n",
    "    numbers = set(numbers)\n",
    "    for i, item in enumerate(sorting_functions.items()):\n",
    "        if i in numbers or not numbers:\n",
    "            result.append(item)\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tylko dla liczb całkowitych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład jednostajny - dużo liczb z małego zakresu - porównanie wszystkich algorytmów\n",
    "Można zauważyć, że w przypadku wielu liczb $ n = O(10000) $, gdzie maksymalnie mamy $ 2000 $ różnych liczb, algorytmy sortowania liniowego działają bardzo szybko i zbliżają się do wbudowanej funkcji sortującej w Pythona. (W kolejnym teście algorytmy sortowania liniowego vs wbudowana funkcja w Pythona)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 25 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0150    Average: 0.0006  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 0.0470    Average: 0.0019  \t(3.13x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 0.0720    Average: 0.0029  \t(4.80x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.1220    Average: 0.0049  \t(8.14x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.1300    Average: 0.0052  \t(8.67x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.1321    Average: 0.0053  \t(8.81x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.1350    Average: 0.0054  \t(9.00x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.1360    Average: 0.0054  \t(9.07x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.1420    Average: 0.0057  \t(9.47x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.3270    Average: 0.0131  \t(21.81x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.3420    Average: 0.0137  \t(22.81x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.4379    Average: 0.0175  \t(29.21x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.4430    Average: 0.0177  \t(29.55x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.4450    Average: 0.0178  \t(29.68x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.4560    Average: 0.0182  \t(30.41x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.4590    Average: 0.0184  \t(30.61x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.4760    Average: 0.0190  \t(31.75x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.4800    Average: 0.0192  \t(32.01x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.4800    Average: 0.0192  \t(32.01x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.5460    Average: 0.0218  \t(36.42x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 0.8200    Average: 0.0328  \t(54.69x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 1.2260    Average: 0.0490  \t(81.77x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 1.2771    Average: 0.0511  \t(85.17x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 1.4220    Average: 0.0569  \t(94.84x slower)\n",
      "Selection Sort                                    Total (in seconds): 28.8290   Average: 1.1532  \t(1922.65x slower)\n",
      "Insertion Sort                                    Total (in seconds): 35.8170   Average: 1.4327  \t(2388.69x slower)\n",
      "Bubble Sort                                       Total (in seconds): 75.7979   Average: 3.0319  \t(5055.09x slower)\n",
      "\n",
      "===== Results after 50 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0340    Average: 0.0007  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 0.1110    Average: 0.0022  \t(3.26x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 0.1440    Average: 0.0029  \t(4.23x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.2540    Average: 0.0051  \t(7.47x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.2680    Average: 0.0054  \t(7.88x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.2681    Average: 0.0054  \t(7.88x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.2790    Average: 0.0056  \t(8.20x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.2850    Average: 0.0057  \t(8.38x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.2880    Average: 0.0058  \t(8.47x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.6740    Average: 0.0135  \t(19.81x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.7051    Average: 0.0141  \t(20.72x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.9048    Average: 0.0181  \t(26.60x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.9110    Average: 0.0182  \t(26.78x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.9160    Average: 0.0183  \t(26.92x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.9400    Average: 0.0188  \t(27.63x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.9480    Average: 0.0190  \t(27.86x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.9710    Average: 0.0194  \t(28.54x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.9850    Average: 0.0197  \t(28.95x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.9890    Average: 0.0198  \t(29.07x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 1.1281    Average: 0.0226  \t(33.16x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 1.6930    Average: 0.0339  \t(49.76x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 2.5280    Average: 0.0506  \t(74.30x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 2.6241    Average: 0.0525  \t(77.13x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 2.9320    Average: 0.0586  \t(86.18x slower)\n",
      "Selection Sort                                    Total (in seconds): 59.1110   Average: 1.1822  \t(1737.41x slower)\n",
      "Insertion Sort                                    Total (in seconds): 73.5390   Average: 1.4708  \t(2161.48x slower)\n",
      "Bubble Sort                                       Total (in seconds): 155.4959  Average: 3.1099  \t(4570.37x slower)\n",
      "\n",
      "===== Results after 75 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0470    Average: 0.0006  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 0.1580    Average: 0.0021  \t(3.36x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 0.2220    Average: 0.0030  \t(4.72x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.3810    Average: 0.0051  \t(8.10x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.4050    Average: 0.0054  \t(8.61x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.4080    Average: 0.0054  \t(8.68x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.4220    Average: 0.0056  \t(8.97x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.4330    Average: 0.0058  \t(9.21x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.4351    Average: 0.0058  \t(9.25x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 1.0189    Average: 0.0136  \t(21.67x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 1.0721    Average: 0.0143  \t(22.80x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 1.3678    Average: 0.0182  \t(29.09x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 1.3840    Average: 0.0185  \t(29.43x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 1.3890    Average: 0.0185  \t(29.54x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 1.4300    Average: 0.0191  \t(30.41x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 1.4341    Average: 0.0191  \t(30.50x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 1.4661    Average: 0.0195  \t(31.18x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 1.4910    Average: 0.0199  \t(31.71x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 1.4970    Average: 0.0200  \t(31.83x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 1.7131    Average: 0.0228  \t(36.43x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 2.5659    Average: 0.0342  \t(54.57x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 3.8220    Average: 0.0510  \t(81.28x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 3.9731    Average: 0.0530  \t(84.49x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 4.4440    Average: 0.0593  \t(94.50x slower)\n",
      "Selection Sort                                    Total (in seconds): 90.3001   Average: 1.2040  \t(1920.29x slower)\n",
      "Insertion Sort                                    Total (in seconds): 112.1810  Average: 1.4957  \t(2385.60x slower)\n",
      "Bubble Sort                                       Total (in seconds): 237.8589  Average: 3.1715  \t(5058.22x slower)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 100 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0580    Average: 0.0006  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 0.1939    Average: 0.0019  \t(3.34x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 0.2820    Average: 0.0028  \t(4.86x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.4860    Average: 0.0049  \t(8.37x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.5211    Average: 0.0052  \t(8.98x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.5230    Average: 0.0052  \t(9.01x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.5380    Average: 0.0054  \t(9.27x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.5500    Average: 0.0055  \t(9.48x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.5551    Average: 0.0056  \t(9.56x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 1.3039    Average: 0.0130  \t(22.47x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 1.3492    Average: 0.0135  \t(23.25x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 1.7307    Average: 0.0173  \t(29.82x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 1.7560    Average: 0.0176  \t(30.26x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 1.7560    Average: 0.0176  \t(30.26x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 1.8009    Average: 0.0180  \t(31.03x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 1.8101    Average: 0.0181  \t(31.19x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 1.8640    Average: 0.0186  \t(32.12x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 1.8940    Average: 0.0189  \t(32.63x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 1.8970    Average: 0.0190  \t(32.69x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 2.1751    Average: 0.0218  \t(37.48x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 3.2559    Average: 0.0326  \t(56.10x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 4.8461    Average: 0.0485  \t(83.50x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 5.0292    Average: 0.0503  \t(86.66x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 5.6250    Average: 0.0563  \t(96.92x slower)\n",
      "Selection Sort                                    Total (in seconds): 112.2361  Average: 1.1224  \t(1933.90x slower)\n",
      "Insertion Sort                                    Total (in seconds): 139.7330  Average: 1.3973  \t(2407.69x slower)\n",
      "Bubble Sort                                       Total (in seconds): 295.5109  Average: 2.9551  \t(5091.85x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 100\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0580361\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   0.1939428\n",
      "\tCounting Sort (#4 - negative & positive)        :   0.2819993\n",
      "\tRadix Sort (#2 - negative & positive)           :   0.4860096\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.5210695\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.5229938\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.5379734\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.5499506\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.5550594\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   1.3038993\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   1.3491526\n",
      "\tMerge Sort (#3)                                 :   1.7307475\n",
      "\tMerge Sort (#1)                                 :   1.7559979\n",
      "\tQuick Sort (#3 - random pivot)                  :   1.7560017\n",
      "\tQuick Sort (#8 - own sorting function)          :   1.8009441\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   1.8100715\n",
      "\tQuicker Sort (#1 - recursive)                   :   1.8640399\n",
      "\tQuick Sort (#5 - static stack)                  :   1.8939652\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   1.8969615\n",
      "\tMerge Sort (#2)                                 :   2.1750751\n",
      "\tHeap Sort (#2)                                  :   3.2559373\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   4.8460846\n",
      "\tHeap Sort (#1)                                  :   5.0292068\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   5.6250215\n",
      "\tSelection Sort                                  :   112.2361290\n",
      "\tInsertion Sort                                  :   139.7329614\n",
      "\tBubble Sort                                     :   295.5108597\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0005804\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   0.0019394\t(3.34x slower)\n",
      "\tCounting Sort (#4 - negative & positive)        :   0.0028200\t(4.86x slower)\n",
      "\tRadix Sort (#2 - negative & positive)           :   0.0048601\t(8.37x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.0052107\t(8.98x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.0052299\t(9.01x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.0053797\t(9.27x slower)\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.0054995\t(9.48x slower)\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.0055506\t(9.56x slower)\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   0.0130390\t(22.47x slower)\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   0.0134915\t(23.25x slower)\n",
      "\tMerge Sort (#3)                                 :   0.0173075\t(29.82x slower)\n",
      "\tMerge Sort (#1)                                 :   0.0175600\t(30.26x slower)\n",
      "\tQuick Sort (#3 - random pivot)                  :   0.0175600\t(30.26x slower)\n",
      "\tQuick Sort (#8 - own sorting function)          :   0.0180094\t(31.03x slower)\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   0.0181007\t(31.19x slower)\n",
      "\tQuicker Sort (#1 - recursive)                   :   0.0186404\t(32.12x slower)\n",
      "\tQuick Sort (#5 - static stack)                  :   0.0189397\t(32.63x slower)\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   0.0189696\t(32.69x slower)\n",
      "\tMerge Sort (#2)                                 :   0.0217508\t(37.48x slower)\n",
      "\tHeap Sort (#2)                                  :   0.0325594\t(56.10x slower)\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   0.0484608\t(83.50x slower)\n",
      "\tHeap Sort (#1)                                  :   0.0502921\t(86.66x slower)\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   0.0562502\t(96.92x slower)\n",
      "\tSelection Sort                                  :   1.1223613\t(1933.90x slower)\n",
      "\tInsertion Sort                                  :   1.3973296\t(2407.69x slower)\n",
      "\tBubble Sort                                     :   2.9551086\t(5091.85x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(), \n",
    "                    samples=100, \n",
    "                    val_counts=(0, 10_000),\n",
    "                    range_=(-1_000, 1_000),\n",
    "                    progress_interval=25,\n",
    "                    uniform_distribution=True,\n",
    "                    ints_only=True\n",
    "                   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład jednostajny - bardzo dużo liczb z małego zakresu - porównanie sortowań liniowych i wbudowanego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 10 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.8499    Average: 0.0850  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 1.8820    Average: 0.1882  \t(2.21x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 3.0080    Average: 0.3008  \t(3.54x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 3.2549    Average: 0.3255  \t(3.83x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 3.6081    Average: 0.3608  \t(4.25x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 4.1410    Average: 0.4141  \t(4.87x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 4.8810    Average: 0.4881  \t(5.74x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 5.3080    Average: 0.5308  \t(6.25x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 12.4200   Average: 1.2420  \t(14.61x slower)\n",
      "\n",
      "===== Results after 20 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 1.7069    Average: 0.0853  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 3.8450    Average: 0.1922  \t(2.25x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 6.0661    Average: 0.3033  \t(3.55x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 6.6069    Average: 0.3303  \t(3.87x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 7.2780    Average: 0.3639  \t(4.26x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 8.3590    Average: 0.4180  \t(4.90x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 9.8580    Average: 0.4929  \t(5.78x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 10.7190   Average: 0.5360  \t(6.28x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 24.9500   Average: 1.2475  \t(14.62x slower)\n",
      "\n",
      "===== Results after 30 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 2.4059    Average: 0.0802  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 5.4540    Average: 0.1818  \t(2.27x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 8.5920    Average: 0.2864  \t(3.57x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 9.3809    Average: 0.3127  \t(3.90x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 10.3300   Average: 0.3443  \t(4.29x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 11.8290   Average: 0.3943  \t(4.92x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 13.9779   Average: 0.4659  \t(5.81x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 15.2330   Average: 0.5078  \t(6.33x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 35.1681   Average: 1.1723  \t(14.62x slower)\n",
      "\n",
      "===== Results after 40 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 3.2549    Average: 0.0814  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 7.3019    Average: 0.1825  \t(2.24x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 11.5870   Average: 0.2897  \t(3.56x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 12.6279   Average: 0.3157  \t(3.88x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 13.8040   Average: 0.3451  \t(4.24x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 15.8401   Average: 0.3960  \t(4.87x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 18.7649   Average: 0.4691  \t(5.77x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 20.3790   Average: 0.5095  \t(6.26x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 47.1220   Average: 1.1781  \t(14.48x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 40\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   3.2548690\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   7.3019497\n",
      "\tCounting Sort (#4 - negative & positive)        :   11.5870423\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   12.6278894\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   13.8040257\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   15.8400776\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   18.7649372\n",
      "\tRadix Sort (#2 - negative & positive)           :   20.3789907\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   47.1220288\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0813717\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   0.1825487\t(2.24x slower)\n",
      "\tCounting Sort (#4 - negative & positive)        :   0.2896761\t(3.56x slower)\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.3156972\t(3.88x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.3451006\t(4.24x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.3960019\t(4.87x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.4691234\t(5.77x slower)\n",
      "\tRadix Sort (#2 - negative & positive)           :   0.5094748\t(6.26x slower)\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   1.1780507\t(14.48x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(*range(18, 27)), \n",
    "                    samples=40, \n",
    "                    val_counts=(0, 1_000_000),\n",
    "                    range_=(-1_000, 1_000),\n",
    "                    progress_interval=10,\n",
    "                    uniform_distribution=True,\n",
    "                    ints_only=True\n",
    "                   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład niejednostajny - duży zakres liczb - porównanie wszystkich sortowań"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 25 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0000    Average: 0.0000  \n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.0070    Average: 0.0003  \n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.0090    Average: 0.0004  \n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.0110    Average: 0.0004  \n",
      "Merge Sort (#3)                                   Total (in seconds): 0.0110    Average: 0.0004  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.0120    Average: 0.0005  \n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.0130    Average: 0.0005  \n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.0140    Average: 0.0006  \n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.0150    Average: 0.0006  \n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.0160    Average: 0.0006  \n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.0170    Average: 0.0007  \n",
      "Merge Sort (#1)                                   Total (in seconds): 0.0180    Average: 0.0007  \n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.0200    Average: 0.0008  \n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.0200    Average: 0.0008  \n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.0200    Average: 0.0008  \n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.0210    Average: 0.0008  \n",
      "Merge Sort (#2)                                   Total (in seconds): 0.0220    Average: 0.0009  \n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.0230    Average: 0.0009  \n",
      "Heap Sort (#2)                                    Total (in seconds): 0.0300    Average: 0.0012  \n",
      "Heap Sort (#1)                                    Total (in seconds): 0.0430    Average: 0.0017  \n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 0.0440    Average: 0.0018  \n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 0.0480    Average: 0.0019  \n",
      "Selection Sort                                    Total (in seconds): 0.0780    Average: 0.0031  \n",
      "Insertion Sort                                    Total (in seconds): 0.0790    Average: 0.0032  \n",
      "Bubble Sort                                       Total (in seconds): 0.1790    Average: 0.0072  \n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 2.7649    Average: 0.1106  \n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 8.6281    Average: 0.3451  \n",
      "\n",
      "===== Results after 50 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0010    Average: 0.0000  \n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.0170    Average: 0.0003  \t(16.98x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.0170    Average: 0.0003  \t(17.00x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.0210    Average: 0.0004  \t(20.98x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.0230    Average: 0.0005  \t(22.99x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.0240    Average: 0.0005  \t(23.98x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.0270    Average: 0.0005  \t(26.99x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.0270    Average: 0.0005  \t(27.02x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.0310    Average: 0.0006  \t(30.99x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.0320    Average: 0.0006  \t(32.01x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.0370    Average: 0.0007  \t(36.97x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.0370    Average: 0.0007  \t(36.98x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.0370    Average: 0.0007  \t(36.99x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.0380    Average: 0.0008  \t(38.00x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.0390    Average: 0.0008  \t(39.01x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.0390    Average: 0.0008  \t(39.04x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.0400    Average: 0.0008  \t(40.00x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.0430    Average: 0.0009  \t(43.04x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 0.0520    Average: 0.0010  \t(51.98x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 0.0820    Average: 0.0016  \t(82.03x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 0.0821    Average: 0.0016  \t(82.07x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 0.0870    Average: 0.0017  \t(87.00x slower)\n",
      "Selection Sort                                    Total (in seconds): 0.1390    Average: 0.0028  \t(139.00x slower)\n",
      "Insertion Sort                                    Total (in seconds): 0.1540    Average: 0.0031  \t(153.98x slower)\n",
      "Bubble Sort                                       Total (in seconds): 0.3310    Average: 0.0066  \t(331.00x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 5.4229    Average: 0.1085  \t(5423.29x slower)\n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 16.8302   Average: 0.3366  \t(16831.38x slower)\n",
      "\n",
      "===== Results after 75 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0020    Average: 0.0000  \n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.0250    Average: 0.0003  \t(12.48x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.0260    Average: 0.0003  \t(12.99x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.0260    Average: 0.0003  \t(13.03x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.0330    Average: 0.0004  \t(16.52x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.0350    Average: 0.0005  \t(17.50x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.0360    Average: 0.0005  \t(17.99x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.0360    Average: 0.0005  \t(18.00x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.0430    Average: 0.0006  \t(21.50x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.0460    Average: 0.0006  \t(23.01x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.0520    Average: 0.0007  \t(26.01x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.0530    Average: 0.0007  \t(26.49x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.0530    Average: 0.0007  \t(26.51x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.0540    Average: 0.0007  \t(27.02x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.0540    Average: 0.0007  \t(27.03x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.0550    Average: 0.0007  \t(27.50x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.0580    Average: 0.0008  \t(29.03x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.0590    Average: 0.0008  \t(29.51x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 0.0730    Average: 0.0010  \t(36.51x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 0.1160    Average: 0.0015  \t(58.03x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 0.1171    Average: 0.0016  \t(58.55x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 0.1250    Average: 0.0017  \t(62.52x slower)\n",
      "Selection Sort                                    Total (in seconds): 0.1940    Average: 0.0026  \t(97.04x slower)\n",
      "Insertion Sort                                    Total (in seconds): 0.2180    Average: 0.0029  \t(109.03x slower)\n",
      "Bubble Sort                                       Total (in seconds): 0.4669    Average: 0.0062  \t(233.57x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 7.9840    Average: 0.1065  \t(3993.69x slower)\n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 25.0392   Average: 0.3339  \t(12524.97x slower)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 100 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0030    Average: 0.0000  \n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.0310    Average: 0.0003  \t(10.32x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.0320    Average: 0.0003  \t(10.68x slower)\n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.0330    Average: 0.0003  \t(10.99x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.0431    Average: 0.0004  \t(14.35x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.0440    Average: 0.0004  \t(14.66x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.0440    Average: 0.0004  \t(14.67x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.0470    Average: 0.0005  \t(15.66x slower)\n",
      "Radix Sort (#2 - negative & positive)             Total (in seconds): 0.0540    Average: 0.0005  \t(18.00x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 0.0580    Average: 0.0006  \t(19.32x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.0590    Average: 0.0006  \t(19.67x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.0640    Average: 0.0006  \t(21.35x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.0660    Average: 0.0007  \t(22.00x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.0690    Average: 0.0007  \t(23.00x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.0690    Average: 0.0007  \t(23.01x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 0.0700    Average: 0.0007  \t(23.34x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.0730    Average: 0.0007  \t(24.35x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.0770    Average: 0.0008  \t(25.67x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 0.0920    Average: 0.0009  \t(30.67x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 0.1470    Average: 0.0015  \t(49.00x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 0.1490    Average: 0.0015  \t(49.69x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 0.1570    Average: 0.0016  \t(52.33x slower)\n",
      "Selection Sort                                    Total (in seconds): 0.2420    Average: 0.0024  \t(80.68x slower)\n",
      "Insertion Sort                                    Total (in seconds): 0.2650    Average: 0.0026  \t(88.34x slower)\n",
      "Bubble Sort                                       Total (in seconds): 0.5730    Average: 0.0057  \t(191.03x slower)\n",
      "Counting Sort (#4 - negative & positive)          Total (in seconds): 10.6540   Average: 0.1065  \t(3552.15x slower)\n",
      "Bucket Sort (#3 - Counting Sort variation)        Total (in seconds): 33.5162   Average: 0.3352  \t(11174.66x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 100\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0029993\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.0309546\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.0320361\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.0329733\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   0.0430512\n",
      "\tMerge Sort (#3)                                 :   0.0439816\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   0.0439880\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.0469677\n",
      "\tRadix Sort (#2 - negative & positive)           :   0.0539873\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.0579596\n",
      "\tMerge Sort (#1)                                 :   0.0590055\n",
      "\tQuick Sort (#8 - own sorting function)          :   0.0640242\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   0.0659893\n",
      "\tQuick Sort (#3 - random pivot)                  :   0.0689771\n",
      "\tMerge Sort (#2)                                 :   0.0690229\n",
      "\tQuicker Sort (#1 - recursive)                   :   0.0700030\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   0.0730195\n",
      "\tQuick Sort (#5 - static stack)                  :   0.0770018\n",
      "\tHeap Sort (#2)                                  :   0.0919795\n",
      "\tHeap Sort (#1)                                  :   0.1469779\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   0.1490431\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   0.1569571\n",
      "\tSelection Sort                                  :   0.2419922\n",
      "\tInsertion Sort                                  :   0.2649670\n",
      "\tBubble Sort                                     :   0.5729666\n",
      "\tCounting Sort (#4 - negative & positive)        :   10.6539798\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   33.5162218\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0000300\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.0003095\t(10.32x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.0003204\t(10.68x slower)\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.0003297\t(10.99x slower)\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   0.0004305\t(14.35x slower)\n",
      "\tMerge Sort (#3)                                 :   0.0004398\t(14.66x slower)\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   0.0004399\t(14.67x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.0004697\t(15.66x slower)\n",
      "\tRadix Sort (#2 - negative & positive)           :   0.0005399\t(18.00x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.0005796\t(19.32x slower)\n",
      "\tMerge Sort (#1)                                 :   0.0005901\t(19.67x slower)\n",
      "\tQuick Sort (#8 - own sorting function)          :   0.0006402\t(21.35x slower)\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   0.0006599\t(22.00x slower)\n",
      "\tQuick Sort (#3 - random pivot)                  :   0.0006898\t(23.00x slower)\n",
      "\tMerge Sort (#2)                                 :   0.0006902\t(23.01x slower)\n",
      "\tQuicker Sort (#1 - recursive)                   :   0.0007000\t(23.34x slower)\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   0.0007302\t(24.35x slower)\n",
      "\tQuick Sort (#5 - static stack)                  :   0.0007700\t(25.67x slower)\n",
      "\tHeap Sort (#2)                                  :   0.0009198\t(30.67x slower)\n",
      "\tHeap Sort (#1)                                  :   0.0014698\t(49.00x slower)\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   0.0014904\t(49.69x slower)\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   0.0015696\t(52.33x slower)\n",
      "\tSelection Sort                                  :   0.0024199\t(80.68x slower)\n",
      "\tInsertion Sort                                  :   0.0026497\t(88.34x slower)\n",
      "\tBubble Sort                                     :   0.0057297\t(191.03x slower)\n",
      "\tCounting Sort (#4 - negative & positive)        :   0.1065398\t(3552.15x slower)\n",
      "\tBucket Sort (#3 - Counting Sort variation)      :   0.3351622\t(11174.66x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(), \n",
    "                    samples=100, \n",
    "                    val_counts=(0, 500),\n",
    "                    range_=(-500_000, 500_000),\n",
    "                    progress_interval=25,\n",
    "                    uniform_distribution=False,\n",
    "                    ints_only=True\n",
    "                   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dla dowolnych liczb wymiernych (zmiennoprzecinkowych)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Odrzucamy algorytm Counting Sort, który się nie nadaje do niczego w przypadku liczb zmiennoprzecinkowych, a także wersję Bucket Sorta, która na nim bazuje. Odrzucamy również Radix Sorta, choć można go zmodyfikować tak, by część dziesiętną traktował jak osobną liczbę i sobie wówczas poradzi z sortowaniem liczb zmiennoprzecinkowych. Poza tymi algorytmami, porównujemy wszystkie pozostałe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład niejednostajny - duży zakres liczb - wszystkie bez odrzuconych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 25 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0100    Average: 0.0004  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.2020    Average: 0.0081  \t(20.26x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.2160    Average: 0.0086  \t(21.67x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.2840    Average: 0.0114  \t(28.48x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.2969    Average: 0.0119  \t(29.79x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.3820    Average: 0.0153  \t(38.32x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.3860    Average: 0.0154  \t(38.72x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.4200    Average: 0.0168  \t(42.13x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.4280    Average: 0.0171  \t(42.94x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.4520    Average: 0.0181  \t(45.35x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.4580    Average: 0.0183  \t(45.94x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.4800    Average: 0.0192  \t(48.15x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 0.7360    Average: 0.0294  \t(73.83x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 0.7380    Average: 0.0295  \t(74.03x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 0.7850    Average: 0.0314  \t(78.74x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 0.9740    Average: 0.0390  \t(97.70x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 1.1280    Average: 0.0451  \t(113.16x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 1.1710    Average: 0.0468  \t(117.47x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 1.2510    Average: 0.0500  \t(125.49x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 1.2820    Average: 0.0513  \t(128.60x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 17.6636   Average: 0.7065  \t(1771.90x slower)\n",
      "Selection Sort                                    Total (in seconds): 25.5451   Average: 1.0218  \t(2562.51x slower)\n",
      "Insertion Sort                                    Total (in seconds): 32.9886   Average: 1.3195  \t(3309.20x slower)\n",
      "Bubble Sort                                       Total (in seconds): 67.8160   Average: 2.7126  \t(6802.85x slower)\n",
      "\n",
      "===== Results after 50 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0180    Average: 0.0004  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.3280    Average: 0.0066  \t(18.27x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.3520    Average: 0.0070  \t(19.60x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.4490    Average: 0.0090  \t(25.00x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.5109    Average: 0.0102  \t(28.46x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.6590    Average: 0.0132  \t(36.70x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.6610    Average: 0.0132  \t(36.82x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 0.7300    Average: 0.0146  \t(40.66x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 0.7450    Average: 0.0149  \t(41.49x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 0.7800    Average: 0.0156  \t(43.44x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 0.7970    Average: 0.0159  \t(44.39x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 0.8309    Average: 0.0166  \t(46.28x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 1.0729    Average: 0.0215  \t(59.76x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 1.2700    Average: 0.0254  \t(70.73x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 1.2919    Average: 0.0258  \t(71.95x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 1.6050    Average: 0.0321  \t(89.39x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 1.7870    Average: 0.0357  \t(99.53x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 1.9560    Average: 0.0391  \t(108.94x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 2.1550    Average: 0.0431  \t(120.02x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 2.2060    Average: 0.0441  \t(122.86x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 23.0015   Average: 0.4600  \t(1281.04x slower)\n",
      "Selection Sort                                    Total (in seconds): 41.3501   Average: 0.8270  \t(2302.95x slower)\n",
      "Insertion Sort                                    Total (in seconds): 53.2736   Average: 1.0655  \t(2967.01x slower)\n",
      "Bubble Sort                                       Total (in seconds): 109.7300  Average: 2.1946  \t(6111.29x slower)\n",
      "\n",
      "===== Results after 75 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0280    Average: 0.0004  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.4890    Average: 0.0065  \t(17.49x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.5200    Average: 0.0069  \t(18.60x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.6470    Average: 0.0086  \t(23.14x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 0.7580    Average: 0.0101  \t(27.11x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 0.9731    Average: 0.0130  \t(34.81x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 0.9770    Average: 0.0130  \t(34.95x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 1.0820    Average: 0.0144  \t(38.70x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 1.1101    Average: 0.0148  \t(39.71x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 1.1650    Average: 0.0155  \t(41.67x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 1.1820    Average: 0.0158  \t(42.28x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 1.2320    Average: 0.0164  \t(44.07x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 1.5630    Average: 0.0208  \t(55.91x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 1.8770    Average: 0.0250  \t(67.14x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 1.8789    Average: 0.0251  \t(67.21x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 2.2980    Average: 0.0306  \t(82.20x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 2.5970    Average: 0.0346  \t(92.90x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 2.8770    Average: 0.0384  \t(102.91x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 3.2040    Average: 0.0427  \t(114.61x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 3.2750    Average: 0.0437  \t(117.15x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 31.7915   Average: 0.4239  \t(1137.21x slower)\n",
      "Selection Sort                                    Total (in seconds): 58.3672   Average: 0.7782  \t(2087.84x slower)\n",
      "Insertion Sort                                    Total (in seconds): 75.3986   Average: 1.0053  \t(2697.07x slower)\n",
      "Bubble Sort                                       Total (in seconds): 154.7970  Average: 2.0640  \t(5537.21x slower)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 100 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.0400    Average: 0.0004  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 0.7020    Average: 0.0070  \t(17.56x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 0.7460    Average: 0.0075  \t(18.66x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 0.9420    Average: 0.0094  \t(23.57x slower)\n",
      "Quick Sort (#2 - Hoare's partition)               Total (in seconds): 1.0699    Average: 0.0107  \t(26.77x slower)\n",
      "Merge Sort (#1)                                   Total (in seconds): 1.3731    Average: 0.0137  \t(34.35x slower)\n",
      "Merge Sort (#3)                                   Total (in seconds): 1.3740    Average: 0.0137  \t(34.37x slower)\n",
      "Quick Sort (#3 - random pivot)                    Total (in seconds): 1.5270    Average: 0.0153  \t(38.20x slower)\n",
      "Quick Sort (#4 - O(log n) memory)                 Total (in seconds): 1.5600    Average: 0.0156  \t(39.03x slower)\n",
      "Quick Sort (#5 - static stack)                    Total (in seconds): 1.6420    Average: 0.0164  \t(41.08x slower)\n",
      "Quick Sort (#6 - dynamic stack)                   Total (in seconds): 1.6600    Average: 0.0166  \t(41.53x slower)\n",
      "Merge Sort (#2)                                   Total (in seconds): 1.7390    Average: 0.0174  \t(43.50x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 2.2550    Average: 0.0225  \t(56.41x slower)\n",
      "Heap Sort (#2)                                    Total (in seconds): 2.6600    Average: 0.0266  \t(66.55x slower)\n",
      "Quick Sort (#1 - Lomuto parition)                 Total (in seconds): 2.8319    Average: 0.0283  \t(70.85x slower)\n",
      "Quick Sort (#8 - own sorting function)            Total (in seconds): 3.4671    Average: 0.0347  \t(86.74x slower)\n",
      "Quicker Sort (#1 - recursive)                     Total (in seconds): 3.7390    Average: 0.0374  \t(93.54x slower)\n",
      "Heap Sort (#1)                                    Total (in seconds): 4.0570    Average: 0.0406  \t(101.49x slower)\n",
      "Quick Sort (#7 - median of medians pivot)         Total (in seconds): 4.5250    Average: 0.0452  \t(113.20x slower)\n",
      "Quicker Sort (#2 - median of medians pivot)       Total (in seconds): 4.6210    Average: 0.0462  \t(115.60x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 50.3596   Average: 0.5036  \t(1259.85x slower)\n",
      "Selection Sort                                    Total (in seconds): 85.0911   Average: 0.8509  \t(2128.73x slower)\n",
      "Insertion Sort                                    Total (in seconds): 109.3706  Average: 1.0937  \t(2736.13x slower)\n",
      "Bubble Sort                                       Total (in seconds): 225.3290  Average: 2.2533  \t(5637.06x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 100\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0399728\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.7020175\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.7460265\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.9420044\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   1.0699444\n",
      "\tMerge Sort (#1)                                 :   1.3730850\n",
      "\tMerge Sort (#3)                                 :   1.3739896\n",
      "\tQuick Sort (#3 - random pivot)                  :   1.5269797\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   1.5600491\n",
      "\tQuick Sort (#5 - static stack)                  :   1.6419985\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   1.6599944\n",
      "\tMerge Sort (#2)                                 :   1.7390027\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   2.2549646\n",
      "\tHeap Sort (#2)                                  :   2.6599936\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   2.8318846\n",
      "\tQuick Sort (#8 - own sorting function)          :   3.4670665\n",
      "\tQuicker Sort (#1 - recursive)                   :   3.7389727\n",
      "\tHeap Sort (#1)                                  :   4.0570300\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   4.5249920\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   4.6210113\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   50.3595541\n",
      "\tSelection Sort                                  :   85.0911145\n",
      "\tInsertion Sort                                  :   109.3706236\n",
      "\tBubble Sort                                     :   225.3289876\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0003997\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.0070202\t(17.56x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.0074603\t(18.66x slower)\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.0094200\t(23.57x slower)\n",
      "\tQuick Sort (#2 - Hoare's partition)             :   0.0106994\t(26.77x slower)\n",
      "\tMerge Sort (#1)                                 :   0.0137309\t(34.35x slower)\n",
      "\tMerge Sort (#3)                                 :   0.0137399\t(34.37x slower)\n",
      "\tQuick Sort (#3 - random pivot)                  :   0.0152698\t(38.20x slower)\n",
      "\tQuick Sort (#4 - O(log n) memory)               :   0.0156005\t(39.03x slower)\n",
      "\tQuick Sort (#5 - static stack)                  :   0.0164200\t(41.08x slower)\n",
      "\tQuick Sort (#6 - dynamic stack)                 :   0.0165999\t(41.53x slower)\n",
      "\tMerge Sort (#2)                                 :   0.0173900\t(43.50x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.0225496\t(56.41x slower)\n",
      "\tHeap Sort (#2)                                  :   0.0265999\t(66.55x slower)\n",
      "\tQuick Sort (#1 - Lomuto parition)               :   0.0283188\t(70.85x slower)\n",
      "\tQuick Sort (#8 - own sorting function)          :   0.0346707\t(86.74x slower)\n",
      "\tQuicker Sort (#1 - recursive)                   :   0.0373897\t(93.54x slower)\n",
      "\tHeap Sort (#1)                                  :   0.0405703\t(101.49x slower)\n",
      "\tQuick Sort (#7 - median of medians pivot)       :   0.0452499\t(113.20x slower)\n",
      "\tQuicker Sort (#2 - median of medians pivot)     :   0.0462101\t(115.60x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.5035955\t(1259.85x slower)\n",
      "\tSelection Sort                                  :   0.8509111\t(2128.73x slower)\n",
      "\tInsertion Sort                                  :   1.0937062\t(2736.13x slower)\n",
      "\tBubble Sort                                     :   2.2532899\t(5637.06x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(*(set(range(0, 27)) - {18, 19, 21})), \n",
    "                    samples=100, \n",
    "                    val_counts=(0, 10_000),\n",
    "                    range_=(-1_000_000_000, 1_000_000_000),\n",
    "                    progress_interval=25,\n",
    "                    uniform_distribution=False,\n",
    "                    ints_only=False\n",
    "                   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład jednostajny - duży zakres liczb - tylko liniowe (bez odrzuconych) i wbudowana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 25 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.1500    Average: 0.0060  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 1.3410    Average: 0.0536  \t(8.94x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 1.3640    Average: 0.0546  \t(9.10x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 1.3765    Average: 0.0551  \t(9.18x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 1.3781    Average: 0.0551  \t(9.19x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 1.4209    Average: 0.0568  \t(9.47x slower)\n",
      "\n",
      "===== Results after 50 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.2910    Average: 0.0058  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 2.5639    Average: 0.0513  \t(8.81x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 2.6125    Average: 0.0523  \t(8.98x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 2.6170    Average: 0.0523  \t(8.99x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 2.6192    Average: 0.0524  \t(9.00x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 2.7048    Average: 0.0541  \t(9.30x slower)\n",
      "\n",
      "===== Results after 75 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.4350    Average: 0.0058  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 3.8489    Average: 0.0513  \t(8.85x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 3.8875    Average: 0.0518  \t(8.94x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 3.9349    Average: 0.0525  \t(9.05x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 3.9803    Average: 0.0531  \t(9.15x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 4.0318    Average: 0.0538  \t(9.27x slower)\n",
      "\n",
      "===== Results after 100 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 0.6279    Average: 0.0063  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 5.5420    Average: 0.0554  \t(8.83x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 5.5574    Average: 0.0556  \t(8.85x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 5.6609    Average: 0.0566  \t(9.02x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 5.6932    Average: 0.0569  \t(9.07x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 5.7458    Average: 0.0575  \t(9.15x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 100\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.6279166\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   5.5419843\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   5.5573978\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   5.6608813\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   5.6932232\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   5.7457874\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.0062792\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.0554198\t(8.83x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.0555740\t(8.85x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.0566088\t(9.02x slower)\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.0569322\t(9.07x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.0574579\t(9.15x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(*(set(range(20, 27)) - {21})), \n",
    "                    samples=100, \n",
    "                    val_counts=(0, 100_000),\n",
    "                    range_=(-100_000_000_000_000, 100_000_000_000_000),\n",
    "                    progress_interval=25,\n",
    "                    uniform_distribution=True,\n",
    "                    ints_only=False\n",
    "                   )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rozkład jednostajny - bardzo mały zakres liczb - tylko liniowe (bez odrzuconych) i wbudowana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Results after 25 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 2.8860    Average: 0.1154  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 17.5510   Average: 0.7020  \t(6.08x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 18.5520   Average: 0.7421  \t(6.43x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 18.6769   Average: 0.7471  \t(6.47x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 18.8218   Average: 0.7529  \t(6.52x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 18.8944   Average: 0.7558  \t(6.55x slower)\n",
      "\n",
      "===== Results after 50 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 4.9240    Average: 0.0985  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 30.5130   Average: 0.6103  \t(6.20x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 32.0650   Average: 0.6413  \t(6.51x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 32.5458   Average: 0.6509  \t(6.61x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 32.6594   Average: 0.6532  \t(6.63x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 32.6799   Average: 0.6536  \t(6.64x slower)\n",
      "\n",
      "===== Results after 75 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 7.2900    Average: 0.0972  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 45.4990   Average: 0.6067  \t(6.24x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 48.0960   Average: 0.6413  \t(6.60x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 48.5657   Average: 0.6475  \t(6.66x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 48.7228   Average: 0.6496  \t(6.68x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 48.7375   Average: 0.6498  \t(6.69x slower)\n",
      "\n",
      "===== Results after 100 tests: =====\n",
      "Sorted (Python's built-in)                        Total (in seconds): 10.0810   Average: 0.1008  \n",
      "Bucket Sort (#5 - iterative with Bucket Sort)     Total (in seconds): 62.3699   Average: 0.6237  \t(6.19x slower)\n",
      "Bucket Sort (#4 - recursive with Bucket Sort)     Total (in seconds): 65.6050   Average: 0.6561  \t(6.51x slower)\n",
      "Bucket Sort (#7 - Quicker Sort & Insertion Sort)  Total (in seconds): 66.0768   Average: 0.6608  \t(6.55x slower)\n",
      "Bucket Sort (#6 - Quick Sort & Insertion Sort)    Total (in seconds): 66.1306   Average: 0.6613  \t(6.56x slower)\n",
      "Bucket Sort (#1 - with Insertion Sort)            Total (in seconds): 66.1668   Average: 0.6617  \t(6.56x slower)\n",
      "\n",
      "===== Final results: =====\n",
      "Tests performed: 100\n",
      "\n",
      "Total times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   10.0810065\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   62.3699045\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   65.6050382\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   66.0767705\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   66.1305652\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   66.1667883\n",
      "\n",
      "Average times (in seconds):\n",
      "\tSorted (Python's built-in)                      :   0.1008101\n",
      "\tBucket Sort (#5 - iterative with Bucket Sort)   :   0.6236990\t(6.19x slower)\n",
      "\tBucket Sort (#4 - recursive with Bucket Sort)   :   0.6560504\t(6.51x slower)\n",
      "\tBucket Sort (#7 - Quicker Sort & Insertion Sort):   0.6607677\t(6.55x slower)\n",
      "\tBucket Sort (#6 - Quick Sort & Insertion Sort)  :   0.6613057\t(6.56x slower)\n",
      "\tBucket Sort (#1 - with Insertion Sort)          :   0.6616679\t(6.56x slower)\n"
     ]
    }
   ],
   "source": [
    "compare_performance(choose(*(set(range(20, 27)) - {21})), \n",
    "                    samples=100, \n",
    "                    val_counts=(0, 1_000_000),\n",
    "                    range_=(-100, 100),\n",
    "                    progress_interval=25,\n",
    "                    uniform_distribution=True,\n",
    "                    ints_only=False\n",
    "                   )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}